diff options
Diffstat (limited to 'build2/variable')
| -rw-r--r-- | build2/variable | 121 |
1 files changed, 73 insertions, 48 deletions
diff --git a/build2/variable b/build2/variable index 9473674..08d0020 100644 --- a/build2/variable +++ b/build2/variable @@ -54,9 +54,9 @@ namespace build2 // and is provided only for diagnostics. Return true if the resulting // value is not empty. // - bool (*const assign) (value&, names&&, const variable*); - bool (*const append) (value&, names&&, const variable*); - bool (*const prepend) (value&, names&&, const variable*); + void (*const assign) (value&, names&&, const variable*); + void (*const append) (value&, names&&, const variable*); + void (*const prepend) (value&, names&&, const variable*); // Reverse the value back to a vector of names. Storage can be used by the // implementation if necessary. Cannot be NULL. @@ -72,6 +72,10 @@ namespace build2 // If NULL, then the types are compared as PODs using memcmp(). // int (*const compare) (const value&, const value&); + + // If NULL, then the value is never empty. + // + bool (*const empty) (const value&); }; enum class variable_visibility @@ -117,29 +121,33 @@ namespace build2 typedef reference_wrapper<const variable> variable_cref; - // value // - enum class value_state: uint8_t {null, empty, filled}; // Order is important. - + // class value { public: const value_type* type; // NULL means this value is not (yet) typed. - value_state state; + bool null; // Extra data that is associated with the value that can be used to store // flags, etc. It is initialized to 0 and copied (but not assigned) from // one value to another but is otherwise untouched (not even when the // value is reset to NULL). // + // Note: if deciding to use for something make sure it is not overlapping + // with an existing usage. + // uint16_t extra; - bool null () const {return state == value_state::null;} - bool empty () const {return state == value_state::empty;} + explicit operator bool () const {return !null;} + bool operator== (nullptr_t) const {return null;} + bool operator!= (nullptr_t) const {return !null;} - explicit operator bool () const {return !null ();} - bool operator== (nullptr_t) const {return null ();} - bool operator!= (nullptr_t) const {return !null ();} + // Check in a type-independent way if the value is empty. The value must + // not be NULL. + // + bool + empty () const; // Creation. A default-initialzied value is NULL and can be reset back to // NULL by assigning nullptr. Values can be copied and copy-assigned. Note @@ -151,8 +159,7 @@ namespace build2 ~value () {*this = nullptr;} explicit - value (const value_type* t = nullptr) - : type (t), state (value_state::null), extra (0) {} + value (const value_type* t = nullptr): type (t), null (true), extra (0) {} explicit value (names&&); // Create untyped value. @@ -160,7 +167,7 @@ namespace build2 // Note: preserves type. // value& - operator= (nullptr_t) {if (!null ()) reset (); return *this;} + operator= (nullptr_t) {if (!null) reset (); return *this;} value (value&&); explicit value (const value&); @@ -302,7 +309,7 @@ namespace build2 // Note: returns true if defined and not NULL. // - explicit operator bool () const {return defined () && !value->null ();} + explicit operator bool () const {return defined () && !value->null;} const value_type& operator* () const {return *value;} const value_type* operator-> () const {return value;} @@ -364,12 +371,12 @@ namespace build2 // // // static T convert (name&&, name* rhs); // - // // Assign/append/prepend T to value and return true if the result is - // // not empty. Value is already of type T but can be NULL. + // // Assign/append/prepend T to value which is already of type T but can + // // be NULL. // // - // static bool assign (value&, T&&); - // static bool append (value&, T&&); - // static bool prepend (value&, T&&); + // static void assign (value&, T&&); + // static void append (value&, T&&); + // static void prepend (value&, T&&); // // // Reverse a value back to name. Only needs to be provided by simple // // types. @@ -380,6 +387,10 @@ namespace build2 // // // static int compare (const T&, const T&); // + // // Return true if the value is empty. + // // + // static bool empty (const T&); + // // // For simple types (those that can be used as elements of containers), // // type_name must be constexpr in order to sidestep the static init // // order issue (in fact, that's the only reason we have it both here @@ -414,6 +425,13 @@ namespace build2 static void default_copy_assign (value&, const value&, bool); + // Default implementations of the empty callback that calls + // value_traits<T>::empty(). + // + template <typename T> + static bool + default_empty (const value&); + // Default implementations of the assign/append/prepend callbacks for simple // types. They call value_traits<T>::convert() and then pass the result to // value_traits<T>::assign()/append()/prepend(). As a result, it may not be @@ -422,15 +440,15 @@ namespace build2 // if false, then an empty value is not allowed. // template <typename T, bool empty> - static bool + static void simple_assign (value&, names&&, const variable*); template <typename T, bool empty> - static bool + static void simple_append (value&, names&&, const variable*); template <typename T, bool empty> - static bool + static void simple_prepend (value&, names&&, const variable*); // Default implementations of the reverse callback for simple types that @@ -456,8 +474,8 @@ namespace build2 static_assert (sizeof (bool) <= value::size_, "insufficient space"); static bool convert (name&&, name*); - static bool assign (value&, bool); - static bool append (value&, bool); // OR. + static void assign (value&, bool); + static void append (value&, bool); // OR. static name reverse (bool x) {return name (x ? "true" : "false");} static int compare (bool, bool); @@ -471,8 +489,8 @@ namespace build2 static_assert (sizeof (uint64_t) <= value::size_, "insufficient space"); static uint64_t convert (name&&, name*); - static bool assign (value&, uint64_t); - static bool append (value&, uint64_t); // ADD. + static void assign (value&, uint64_t); + static void append (value&, uint64_t); // ADD. static name reverse (uint64_t x) {return name (to_string (x));} static int compare (uint64_t, uint64_t); @@ -488,11 +506,12 @@ namespace build2 static_assert (sizeof (string) <= value::size_, "insufficient space"); static string convert (name&&, name*); - static bool assign (value&, string&&); - static bool append (value&, string&&); - static bool prepend (value&, string&&); + static void assign (value&, string&&); + static void append (value&, string&&); + static void prepend (value&, string&&); static name reverse (const string& x) {return name (x);} static int compare (const string&, const string&); + static bool empty (const string& x) {return x.empty ();} static const char* const type_name; static const build2::value_type value_type; @@ -506,11 +525,12 @@ namespace build2 static_assert (sizeof (path) <= value::size_, "insufficient space"); static path convert (name&&, name*); - static bool assign (value&, path&&); - static bool append (value&, path&&); // operator/ - static bool prepend (value&, path&&); // operator/ + static void assign (value&, path&&); + static void append (value&, path&&); // operator/ + static void prepend (value&, path&&); // operator/ static name reverse (const path& x) {return name (x.string ());} static int compare (const path&, const path&); + static bool empty (const path& x) {return x.empty ();} static const char* const type_name; static const build2::value_type value_type; @@ -524,11 +544,12 @@ namespace build2 static_assert (sizeof (dir_path) <= value::size_, "insufficient space"); static dir_path convert (name&&, name*); - static bool assign (value&, dir_path&&); - static bool append (value&, dir_path&&); // operator/ - static bool prepend (value&, dir_path&&); // operator/ + static void assign (value&, dir_path&&); + static void append (value&, dir_path&&); // operator/ + static void prepend (value&, dir_path&&); // operator/ static name reverse (const dir_path& x) {return name (x);} static int compare (const dir_path&, const dir_path&); + static bool empty (const dir_path& x) {return x.empty ();} static const char* const type_name; static const build2::value_type value_type; @@ -543,10 +564,11 @@ namespace build2 "insufficient space"); static abs_dir_path convert (name&&, name*); - static bool assign (value&, abs_dir_path&&); - static bool append (value&, abs_dir_path&&); // operator/ + static void assign (value&, abs_dir_path&&); + static void append (value&, abs_dir_path&&); // operator/ static name reverse (const abs_dir_path& x) {return name (x);} static int compare (const abs_dir_path&, const abs_dir_path&); + static bool empty (const abs_dir_path& x) {return x.empty ();} static const char* const type_name; static const build2::value_type value_type; @@ -560,11 +582,12 @@ namespace build2 static_assert (sizeof (name) <= value::size_, "insufficient space"); static name convert (name&&, name*); - static bool assign (value&, name&&); - static bool append (value&, name&&); - static bool prepend (value&, name&&); + static void assign (value&, name&&); + static void append (value&, name&&); + static void prepend (value&, name&&); static name reverse (const name& x) {return x;} static int compare (const name&, const name&); + static bool empty (const name& x) {return x.empty ();} static const char* const type_name; static const build2::value_type value_type; @@ -577,9 +600,10 @@ namespace build2 { static_assert (sizeof (vector<T>) <= value::size_, "insufficient space"); - static bool assign (value&, vector<T>&&); - static bool append (value&, vector<T>&&); - static bool prepend (value&, vector<T>&&); + static void assign (value&, vector<T>&&); + static void append (value&, vector<T>&&); + static void prepend (value&, vector<T>&&); + static bool empty (const vector<T>& x) {return x.empty ();} static const string type_name; static const build2::value_type value_type; @@ -594,10 +618,11 @@ namespace build2 static_assert (sizeof (map<K, V>) <= value::size_, "insufficient space"); - static bool assign (value&, map<K, V>&&); - static bool append (value&, map<K, V>&&); - static bool prepend (value& v, map<K, V>&& x) { + static void assign (value&, map<K, V>&&); + static void append (value&, map<K, V>&&); + static void prepend (value& v, map<K, V>&& x) { return append (v, move (x));} + static bool empty (const map<K, V>& x) {return x.empty ();} static const string type_name; static const build2::value_type value_type; |