From 9fb791e9fad6c63fc1dac49f4d05ae63b8a3db9b Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Tue, 5 Jan 2016 11:55:15 +0200
Subject: Rename build directory/namespace to build2

---
 build2/variable.ixx | 398 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 398 insertions(+)
 create mode 100644 build2/variable.ixx

(limited to 'build2/variable.ixx')

diff --git a/build2/variable.ixx b/build2/variable.ixx
new file mode 100644
index 0000000..2933deb
--- /dev/null
+++ b/build2/variable.ixx
@@ -0,0 +1,398 @@
+// file      : build2/variable.ixx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+namespace build2
+{
+  // value
+  //
+  template <typename T>
+  inline void
+  assign (value& v, const variable& var)
+  {
+    auto t (&value_traits<T>::value_type);
+
+    if (v.type != t)
+      assign (v, t, var);
+  }
+
+  template <typename T>
+  inline typename value_traits<T>::type
+  as (value& v)
+  {
+    return value_traits<T>::as (v);
+  }
+
+  template <typename T>
+  inline typename value_traits<T>::const_type
+  as (const value& v)
+  {
+    return value_traits<T>::as (v);
+  }
+
+  template <typename T>
+  inline bool
+  assign (name& n)
+  {
+    return value_traits<T>::assign (n);
+  }
+
+  template <typename T>
+  inline typename value_traits<T>::type
+  as (name& n)
+  {
+    return value_traits<T>::as (n);
+  }
+
+  template <typename T>
+  inline typename value_traits<T>::const_type
+  as (const name& n)
+  {
+    return value_traits<T>::as (n);
+  }
+
+  template <typename T>
+  inline value& value::
+  operator= (T v)
+  {
+    value_traits<T>::assign (*this, std::move (v));
+    return *this;
+  }
+
+  template <typename T>
+  inline value& value::
+  operator+= (T v)
+  {
+    value_traits<T>::append (*this, std::move (v));
+    return *this;
+  }
+
+  inline void value::
+  assign (names v, const variable& var)
+  {
+    data_ = std::move (v);
+    state_ = (type != nullptr && type->assign != nullptr
+              ? type->assign (data_, var)
+              : !data_.empty ())
+      ? state_type::filled
+      : state_type::empty;
+  }
+
+  // bool value
+  //
+  inline bool_value<name> value_traits<bool>::
+  as (value& v)
+  {
+    assert (v.type == bool_type);
+    return bool_value<name> (v.data_.front ());
+  }
+
+  inline bool_value<const name> value_traits<bool>::
+  as (const value& v)
+  {
+    assert (v.type == bool_type);
+    return bool_value<const name> (v.data_.front ());
+  }
+
+  inline void value_traits<bool>::
+  assign (value& v, bool x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = bool_type;
+      v.data_.emplace_back (name ());
+      v.state_ = value::state_type::empty;
+    }
+
+    as (v) = x;
+    v.state_ = value::state_type::filled;
+  }
+
+  inline void value_traits<bool>::
+  append (value& v, bool x)
+  {
+    if (v.null ())
+      assign (v, x);
+    else
+      as (v) += x; // Cannot be empty.
+  }
+
+  // string value
+  //
+  inline std::string& value_traits<std::string>::
+  as (value& v)
+  {
+    assert (v.type == string_type);
+    return v.data_.front ().value;
+  }
+
+  inline const std::string& value_traits<std::string>::
+  as (const value& v)
+  {
+    assert (v.type == string_type);
+    return v.data_.front ().value;
+  }
+
+  inline void value_traits<std::string>::
+  assign (value& v, std::string x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = string_type;
+      v.data_.emplace_back (name ());
+      v.state_ = value::state_type::empty;
+    }
+
+    v.state_ = (as (v) = std::move (x)).empty ()
+      ? value::state_type::empty
+      : value::state_type::filled;
+  }
+
+  inline void value_traits<std::string>::
+  append (value& v, std::string x)
+  {
+    if (v.null ())
+      assign (v, std::move (x));
+    else
+      v.state_ = (as (v) += std::move (x)).empty ()
+        ? value::state_type::empty
+        : value::state_type::filled;
+  }
+
+  // dir_path value
+  //
+  inline dir_path& value_traits<dir_path>::
+  as (value& v)
+  {
+    assert (v.type == dir_path_type);
+    return v.data_.front ().dir;
+  }
+
+  inline const dir_path& value_traits<dir_path>::
+  as (const value& v)
+  {
+    assert (v.type == dir_path_type);
+    return v.data_.front ().dir;
+  }
+
+  inline void value_traits<dir_path>::
+  assign (value& v, dir_path x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = dir_path_type;
+      v.data_.emplace_back (name ());
+      v.state_ = value::state_type::empty;
+    }
+
+    v.state_ = (as (v) = std::move (x)).empty ()
+      ? value::state_type::empty
+      : value::state_type::filled;
+  }
+
+  inline void value_traits<dir_path>::
+  append (value& v, dir_path x)
+  {
+    if (v.null ())
+      assign (v, std::move (x));
+    else
+      v.state_ = (as (v) /= std::move (x)).empty ()
+        ? value::state_type::empty
+        : value::state_type::filled;
+  }
+
+  // name value
+  //
+  inline name& value_traits<name>::
+  as (value& v)
+  {
+    assert (v.type == name_type);
+    return v.data_.front ();
+  }
+
+  inline const name& value_traits<name>::
+  as (const value& v)
+  {
+    assert (v.type == name_type);
+    return v.data_.front ();
+  }
+
+  inline void value_traits<name>::
+  assign (value& v, name x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = name_type;
+      v.data_.emplace_back (name ());
+      v.state_ = value::state_type::empty;
+    }
+
+    v.state_ = (as (v) = std::move (x)).empty ()
+      ? value::state_type::empty
+      : value::state_type::filled;
+  }
+
+  // vector<T> value
+  //
+  template <typename T, typename D>
+  inline vector_value<T, D>& vector_value<T, D>::
+  assign (std::vector<T> v)
+  {
+    d->clear ();
+    d->insert (d->end (),
+               std::make_move_iterator (v.begin ()),
+               std::make_move_iterator (v.end ()));
+    return *this;
+  }
+
+  template <typename T, typename D>
+  template <typename D1>
+  inline vector_value<T, D>& vector_value<T, D>::
+  assign (const vector_value<T, D1>& v)
+  {
+    d->clear ();
+    d->insert (d->end (), v.begin (), v.end ());
+    return *this;
+  }
+
+  template <typename T, typename D>
+  template <typename D1>
+  inline vector_value<T, D>& vector_value<T, D>::
+  append (const vector_value<T, D1>& v)
+  {
+    d->insert (d->end (), v.begin (), v.end ());
+    return *this;
+  }
+
+  template <typename T>
+  inline vector_value<T, names> value_traits<std::vector<T>>::
+  as (value& v)
+  {
+    assert (v.type == &value_traits<std::vector<T>>::value_type);
+    return vector_value<T, names> (v.data_);
+  }
+
+  template <typename T>
+  inline vector_value<T, const names> value_traits<std::vector<T>>::
+  as (const value& v)
+  {
+    assert (v.type == &value_traits<std::vector<T>>::value_type);
+    return vector_value<T, const names> (v.data_);
+  }
+
+  template <typename T>
+  template <typename V>
+  inline void value_traits<std::vector<T>>::
+  assign (value& v, V x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = &value_traits<std::vector<T>>::value_type;
+      v.state_ = value::state_type::empty;
+    }
+
+    v.state_ = (as (v).assign (std::move (x))).empty ()
+      ? value::state_type::empty
+      : value::state_type::filled;
+  }
+
+  template <typename T>
+  template <typename V>
+  inline void value_traits<std::vector<T>>::
+  append (value& v, V x)
+  {
+    if (v.null ())
+      assign (v, std::move (x));
+    else
+      v.state_ = (as (v).append (std::move (x))).empty ()
+        ? value::state_type::empty
+        : value::state_type::filled;
+  }
+
+  // map<K, V> value
+  //
+  template <typename K, typename V>
+  inline map_value<K, V, names> value_traits<std::map<K, V>>::
+  as (value& v)
+  {
+    assert ((v.type == &value_traits<std::map<K, V>>::value_type));
+    return map_value<K, V, names> (v.data_);
+  }
+
+  template <typename K, typename V>
+  inline map_value<K, V, const names> value_traits<std::map<K, V>>::
+  as (const value& v)
+  {
+    assert ((v.type == &value_traits<std::map<K, V>>::value_type));
+    return map_value<K, V, const names> (v.data_);
+  }
+
+  template <typename K, typename V>
+  template <typename M>
+  inline void value_traits<std::map<K, V>>::
+  assign (value& v, M x)
+  {
+    if (v.null ())
+    {
+      if (v.type == nullptr)
+        v.type = &value_traits<std::map<K, V>>::value_type;
+      v.state_ = value::state_type::empty;
+    }
+
+    v.state_ = (as (v).assign (std::move (x))).empty ()
+      ? value::state_type::empty
+      : value::state_type::filled;
+  }
+
+  template <typename K, typename V>
+  template <typename M>
+  inline void value_traits<std::map<K, V>>::
+  append (value& v, M x)
+  {
+    if (v.null ())
+      assign (v, std::move (x));
+    else
+      v.state_ = (as (v).append (std::move (x))).empty ()
+        ? value::state_type::empty
+        : value::state_type::filled;
+  }
+
+  // variable_map::iterator_adapter
+  //
+  template <typename I>
+  inline typename I::reference variable_map::iterator_adapter<I>::
+  operator* () const
+  {
+    auto& r (I::operator* ());
+    const variable& var (r.first);
+    auto& val (r.second);
+
+    // First access after being assigned a type?
+    //
+    if (var.type != nullptr && val.type != var.type)
+      build2::assign (const_cast<value&> (val), var.type, var);
+
+    return r;
+  }
+
+  template <typename I>
+  inline typename I::pointer variable_map::iterator_adapter<I>::
+  operator-> () const
+  {
+    auto p (I::operator-> ());
+    const variable& var (p->first);
+    auto& val (p->second);
+
+    // First access after being assigned a type?
+    //
+    if (var.type != nullptr && val.type != var.type)
+      build2::assign (const_cast<value&> (val), var.type, var);
+
+    return p;
+  }
+}
-- 
cgit v1.1