head 1.2; access; symbols netbsd-11-0-RC6:1.2 netbsd-11-0-RC5:1.2 netbsd-11-0-RC4:1.2 netbsd-11-0-RC3:1.2 netbsd-11-0-RC2:1.2 netbsd-11-0-RC1:1.2 perseant-exfatfs-base-20250801:1.2 netbsd-11:1.2.0.10 netbsd-11-base:1.2 netbsd-10-1-RELEASE:1.2 perseant-exfatfs-base-20240630:1.2 perseant-exfatfs:1.2.0.8 perseant-exfatfs-base:1.2 netbsd-8-3-RELEASE:1.1.1.1 netbsd-9-4-RELEASE:1.1.1.1 netbsd-10-0-RELEASE:1.2 netbsd-10-0-RC6:1.2 netbsd-10-0-RC5:1.2 netbsd-10-0-RC4:1.2 netbsd-10-0-RC3:1.2 netbsd-10-0-RC2:1.2 netbsd-10-0-RC1:1.2 netbsd-10:1.2.0.6 netbsd-10-base:1.2 netbsd-9-3-RELEASE:1.1.1.1 cjep_sun2x-base1:1.2 cjep_sun2x:1.2.0.4 cjep_sun2x-base:1.2 cjep_staticlib_x-base1:1.2 netbsd-9-2-RELEASE:1.1.1.1 cjep_staticlib_x:1.2.0.2 cjep_staticlib_x-base:1.2 netbsd-9-1-RELEASE:1.1.1.1 phil-wifi-20200421:1.1.1.1 phil-wifi-20200411:1.1.1.1 is-mlppp:1.1.1.1.0.40 is-mlppp-base:1.1.1.1 phil-wifi-20200406:1.1.1.1 netbsd-8-2-RELEASE:1.1.1.1 netbsd-9-0-RELEASE:1.1.1.1 netbsd-9-0-RC2:1.1.1.1 netbsd-9-0-RC1:1.1.1.1 phil-wifi-20191119:1.1.1.1 netbsd-9:1.1.1.1.0.38 netbsd-9-base:1.1.1.1 phil-wifi-20190609:1.1.1.1 netbsd-8-1-RELEASE:1.1.1.1 netbsd-8-1-RC1:1.1.1.1 pgoyette-compat-merge-20190127:1.1.1.1 pgoyette-compat-20190127:1.1.1.1 pgoyette-compat-20190118:1.1.1.1 pgoyette-compat-1226:1.1.1.1 pgoyette-compat-1126:1.1.1.1 pgoyette-compat-1020:1.1.1.1 pgoyette-compat-0930:1.1.1.1 pgoyette-compat-0906:1.1.1.1 netbsd-7-2-RELEASE:1.1.1.1 pgoyette-compat-0728:1.1.1.1 netbsd-8-0-RELEASE:1.1.1.1 phil-wifi:1.1.1.1.0.36 phil-wifi-base:1.1.1.1 pgoyette-compat-0625:1.1.1.1 netbsd-8-0-RC2:1.1.1.1 pgoyette-compat-0521:1.1.1.1 pgoyette-compat-0502:1.1.1.1 pgoyette-compat-0422:1.1.1.1 netbsd-8-0-RC1:1.1.1.1 pgoyette-compat-0415:1.1.1.1 pgoyette-compat-0407:1.1.1.1 pgoyette-compat-0330:1.1.1.1 pgoyette-compat-0322:1.1.1.1 pgoyette-compat-0315:1.1.1.1 netbsd-7-1-2-RELEASE:1.1.1.1 pgoyette-compat:1.1.1.1.0.34 pgoyette-compat-base:1.1.1.1 netbsd-7-1-1-RELEASE:1.1.1.1 matt-nb8-mediatek:1.1.1.1.0.32 matt-nb8-mediatek-base:1.1.1.1 perseant-stdc-iso10646:1.1.1.1.0.30 perseant-stdc-iso10646-base:1.1.1.1 netbsd-8:1.1.1.1.0.28 netbsd-8-base:1.1.1.1 prg-localcount2-base3:1.1.1.1 prg-localcount2-base2:1.1.1.1 prg-localcount2-base1:1.1.1.1 prg-localcount2:1.1.1.1.0.26 prg-localcount2-base:1.1.1.1 pgoyette-localcount-20170426:1.1.1.1 bouyer-socketcan-base1:1.1.1.1 pgoyette-localcount-20170320:1.1.1.1 netbsd-7-1:1.1.1.1.0.24 netbsd-7-1-RELEASE:1.1.1.1 netbsd-7-1-RC2:1.1.1.1 netbsd-7-nhusb-base-20170116:1.1.1.1 bouyer-socketcan:1.1.1.1.0.22 bouyer-socketcan-base:1.1.1.1 pgoyette-localcount-20170107:1.1.1.1 netbsd-7-1-RC1:1.1.1.1 pgoyette-localcount-20161104:1.1.1.1 netbsd-7-0-2-RELEASE:1.1.1.1 localcount-20160914:1.1.1.1 netbsd-7-nhusb:1.1.1.1.0.20 netbsd-7-nhusb-base:1.1.1.1 pgoyette-localcount-20160806:1.1.1.1 pgoyette-localcount-20160726:1.1.1.1 pgoyette-localcount:1.1.1.1.0.18 pgoyette-localcount-base:1.1.1.1 netbsd-7-0-1-RELEASE:1.1.1.1 netbsd-7-0:1.1.1.1.0.16 netbsd-7-0-RELEASE:1.1.1.1 netbsd-7-0-RC3:1.1.1.1 netbsd-7-0-RC2:1.1.1.1 netbsd-7-0-RC1:1.1.1.1 netbsd-7:1.1.1.1.0.14 netbsd-7-base:1.1.1.1 yamt-pagecache:1.1.1.1.0.12 yamt-pagecache-base9:1.1.1.1 tls-earlyentropy:1.1.1.1.0.10 tls-earlyentropy-base:1.1.1.1 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1 riastradh-drm2-base3:1.1.1.1 kyua-cli-0-7:1.1.1.1 riastradh-drm2-base2:1.1.1.1 riastradh-drm2-base1:1.1.1.1 riastradh-drm2:1.1.1.1.0.2 riastradh-drm2-base:1.1.1.1 khorben-n900:1.1.1.1.0.8 agc-symver:1.1.1.1.0.6 agc-symver-base:1.1.1.1 tls-maxphys-base:1.1.1.1 tls-maxphys:1.1.1.1.0.4 kyua-cli-0-6:1.1.1.1 GOOGLE-CODE:1.1.1; locks; strict; comment @// @; 1.2 date 2020.07.02.14.04.00; author lukem; state Exp; branches; next 1.1; commitid YUoDcZ95aoStLveC; 1.1 date 2013.02.23.12.34.06; author jmmv; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 2013.02.23.12.34.06; author jmmv; state Exp; branches 1.1.1.1.4.1 1.1.1.1.12.1; next ; 1.1.1.1.4.1 date 2013.02.23.12.34.06; author tls; state dead; branches; next 1.1.1.1.4.2; 1.1.1.1.4.2 date 2013.02.25.00.26.15; author tls; state Exp; branches; next ; 1.1.1.1.12.1 date 2013.02.23.12.34.06; author yamt; state dead; branches; next 1.1.1.1.12.2; commitid h3iiOYJJCkPr7yBx; 1.1.1.1.12.2 date 2014.05.22.15.45.29; author yamt; state Exp; branches; next ; commitid h3iiOYJJCkPr7yBx; desc @@ 1.2 log @kyua-cli: convert auto_ptr to unique_ptr Update kyua-cli to C++11 and use unique_ptr instead of auto_ptr, (with std::move() where appropriate), to avoid deprecated warning by g++ 8. (I didn't change some of the code that could arguably be refactored to use unique_ptr or shared_ptr instead of raw pointers and therefore remove the special case destructor handling). @ text @// Copyright 2012 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/config/nodes.ipp" #include #include #include "utils/config/exceptions.hpp" #include "utils/config/keys.hpp" #include "utils/format/macros.hpp" namespace config = utils::config; /// Destructor. config::detail::base_node::~base_node(void) { } /// Constructor. /// /// \param dynamic_ Whether the node is dynamic or not. config::detail::inner_node::inner_node(const bool dynamic_) : _dynamic(dynamic_) { } /// Destructor. config::detail::inner_node::~inner_node(void) { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) delete (*iter).second; } /// Fills the given node with a copy of this node's data. /// /// \param node The node to fill. Should be the fresh return value of a /// deep_copy() operation. void config::detail::inner_node::copy_into(inner_node* node) const { node->_dynamic = _dynamic; for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { base_node* new_node = (*iter).second->deep_copy(); try { node->_children[(*iter).first] = new_node; } catch (...) { delete new_node; throw; } } } /// Finds a node without creating it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key. /// The returned node is constant, so this can only be used for querying /// purposes. For this reason, this algorithm does not create intermediate /// nodes if they don't exist (as would be necessary to set a new node). /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. const config::detail::base_node* config::detail::inner_node::lookup_ro(const tree_key& key, const tree_key::size_type key_pos) const { PRE(key_pos < key.size()); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) throw unknown_key_error(key); if (key_pos == key.size() - 1) { return (*child_iter).second; } else { PRE(key_pos < key.size() - 1); try { const inner_node& child = dynamic_cast< const inner_node& >( *(*child_iter).second); return child.lookup_ro(key, key_pos + 1); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Finds a node and creates it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key, /// creating any intermediate nodes if they do not already exist (for the case /// of dynamic inner nodes). The returned node is non-constant, so this can be /// used by the algorithms that set key values. /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. This is only called if the leaf cannot be found, but it has /// already been defined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. /// \throw value_error If the resulting node of the search would be an inner /// node. config::leaf_node* config::detail::inner_node::lookup_rw(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); children_map::const_iterator child_iter = _children.find(key[key_pos]); if (child_iter == _children.end()) { if (_dynamic) { base_node* const child = (key_pos == key.size() - 1) ? static_cast< base_node* >(new_node()) : static_cast< base_node* >(new dynamic_inner_node()); _children.insert(children_map::value_type(key[key_pos], child)); child_iter = _children.find(key[key_pos]); } else { throw unknown_key_error(key); } } if (key_pos == key.size() - 1) { try { leaf_node& child = dynamic_cast< leaf_node& >( *(*child_iter).second); return &child; } catch (const std::bad_cast& unused_error) { throw value_error(F("Invalid value for key '%s'") % flatten_key(key)); } } else { PRE(key_pos < key.size() - 1); try { inner_node& child = dynamic_cast< inner_node& >( *(*child_iter).second); return child.lookup_rw(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Converts the subtree to a collection of key/value string pairs. /// /// \param [out] properties The accumulator for the generated properties. The /// contents of the map are only extended. /// \param key The path to the current node. void config::detail::inner_node::all_properties(properties_map& properties, const tree_key& key) const { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { tree_key child_key = key; child_key.push_back((*iter).first); try { leaf_node& child = dynamic_cast< leaf_node& >(*(*iter).second); if (child.is_set()) properties[flatten_key(child_key)] = child.to_string(); } catch (const std::bad_cast& unused_error) { inner_node& child = dynamic_cast< inner_node& >(*(*iter).second); child.all_properties(properties, child_key); } } } /// Constructor. config::detail::static_inner_node::static_inner_node(void) : inner_node(false) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::static_inner_node::deep_copy(void) const { std::unique_ptr< inner_node > new_node(new static_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Registers a key as valid and having a specific type. /// /// This method does not raise errors on invalid/unknown keys or other /// tree-related issues. The reasons is that define() is a method that does not /// depend on user input: it is intended to pre-populate the tree with a /// specific structure, and that happens once at coding time. /// /// \param key The key to be registered. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. void config::detail::static_inner_node::define(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); if (key_pos == key.size() - 1) { PRE_MSG(_children.find(key[key_pos]) == _children.end(), "Key already defined"); _children.insert(children_map::value_type(key[key_pos], new_node())); } else { PRE(key_pos < key.size() - 1); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) { static_inner_node* const child_ptr = new static_inner_node(); _children.insert(children_map::value_type(key[key_pos], child_ptr)); child_ptr->define(key, key_pos + 1, new_node); } else { try { static_inner_node& child = dynamic_cast< static_inner_node& >( *(*child_iter).second); child.define(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { UNREACHABLE; } } } } /// Constructor. config::detail::dynamic_inner_node::dynamic_inner_node(void) : inner_node(true) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::dynamic_inner_node::deep_copy(void) const { std::unique_ptr< inner_node > new_node(new dynamic_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Destructor. config::leaf_node::~leaf_node(void) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::bool_node::deep_copy(void) const { std::unique_ptr< bool_node > new_node(new bool_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::bool_node::push_lua(lutok::state& state) const { state.push_boolean(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::bool_node::set_lua(lutok::state& state, const int value_index) { if (state.is_boolean(value_index)) set(state.to_boolean(value_index)); else throw value_error("Not a boolean"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::int_node::deep_copy(void) const { std::unique_ptr< int_node > new_node(new int_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::int_node::push_lua(lutok::state& state) const { state.push_integer(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::int_node::set_lua(lutok::state& state, const int value_index) { if (state.is_number(value_index)) set(state.to_integer(value_index)); else throw value_error("Not an integer"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::string_node::deep_copy(void) const { std::unique_ptr< string_node > new_node(new string_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::string_node::push_lua(lutok::state& state) const { state.push_string(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::string_node::set_lua(lutok::state& state, const int value_index) { if (state.is_string(value_index)) set(state.to_string(value_index)); else throw value_error("Not a string"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::strings_set_node::deep_copy(void) const { std::unique_ptr< strings_set_node > new_node(new strings_set_node()); new_node->_value = _value; return new_node.release(); } /// Converts a single word to the native type. /// /// \param raw_value The value to parse. /// /// \return The parsed value. std::string config::strings_set_node::parse_one(const std::string& raw_value) const { return raw_value; } @ 1.1 log @Initial revision @ text @d226 1 a226 1 std::auto_ptr< inner_node > new_node(new static_inner_node()); d289 1 a289 1 std::auto_ptr< inner_node > new_node(new dynamic_inner_node()); d307 1 a307 1 std::auto_ptr< bool_node > new_node(new bool_node()); d346 1 a346 1 std::auto_ptr< int_node > new_node(new int_node()); d385 1 a385 1 std::auto_ptr< string_node > new_node(new string_node()); d424 1 a424 1 std::auto_ptr< strings_set_node > new_node(new strings_set_node()); @ 1.1.1.1 log @Initial import of Kyua CLI, version 0.6: This is the main component of Kyua and its build will be guarded by the MKKYUA knob. core@@ has approved this import. Description: Kyua (pronounced Q.A.) is a testing framework for both developers and users. Kyua is different from most other testing frameworks in that it puts the end user experience before anything else. There are multiple reasons for users to run the tests themselves, and Kyua ensures that they can do so in the most convenient way. This module, kyua-cli, provides the command-line interface to the Kyua runtime system. The major purpose of this tool is to run test cases and generate unified reports for their results. @ text @@ 1.1.1.1.12.1 log @file nodes.cpp was added on branch yamt-pagecache on 2014-05-22 15:45:29 +0000 @ text @d1 439 @ 1.1.1.1.12.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 439 // Copyright 2012 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/config/nodes.ipp" #include #include #include "utils/config/exceptions.hpp" #include "utils/config/keys.hpp" #include "utils/format/macros.hpp" namespace config = utils::config; /// Destructor. config::detail::base_node::~base_node(void) { } /// Constructor. /// /// \param dynamic_ Whether the node is dynamic or not. config::detail::inner_node::inner_node(const bool dynamic_) : _dynamic(dynamic_) { } /// Destructor. config::detail::inner_node::~inner_node(void) { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) delete (*iter).second; } /// Fills the given node with a copy of this node's data. /// /// \param node The node to fill. Should be the fresh return value of a /// deep_copy() operation. void config::detail::inner_node::copy_into(inner_node* node) const { node->_dynamic = _dynamic; for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { base_node* new_node = (*iter).second->deep_copy(); try { node->_children[(*iter).first] = new_node; } catch (...) { delete new_node; throw; } } } /// Finds a node without creating it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key. /// The returned node is constant, so this can only be used for querying /// purposes. For this reason, this algorithm does not create intermediate /// nodes if they don't exist (as would be necessary to set a new node). /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. const config::detail::base_node* config::detail::inner_node::lookup_ro(const tree_key& key, const tree_key::size_type key_pos) const { PRE(key_pos < key.size()); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) throw unknown_key_error(key); if (key_pos == key.size() - 1) { return (*child_iter).second; } else { PRE(key_pos < key.size() - 1); try { const inner_node& child = dynamic_cast< const inner_node& >( *(*child_iter).second); return child.lookup_ro(key, key_pos + 1); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Finds a node and creates it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key, /// creating any intermediate nodes if they do not already exist (for the case /// of dynamic inner nodes). The returned node is non-constant, so this can be /// used by the algorithms that set key values. /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. This is only called if the leaf cannot be found, but it has /// already been defined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. /// \throw value_error If the resulting node of the search would be an inner /// node. config::leaf_node* config::detail::inner_node::lookup_rw(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); children_map::const_iterator child_iter = _children.find(key[key_pos]); if (child_iter == _children.end()) { if (_dynamic) { base_node* const child = (key_pos == key.size() - 1) ? static_cast< base_node* >(new_node()) : static_cast< base_node* >(new dynamic_inner_node()); _children.insert(children_map::value_type(key[key_pos], child)); child_iter = _children.find(key[key_pos]); } else { throw unknown_key_error(key); } } if (key_pos == key.size() - 1) { try { leaf_node& child = dynamic_cast< leaf_node& >( *(*child_iter).second); return &child; } catch (const std::bad_cast& unused_error) { throw value_error(F("Invalid value for key '%s'") % flatten_key(key)); } } else { PRE(key_pos < key.size() - 1); try { inner_node& child = dynamic_cast< inner_node& >( *(*child_iter).second); return child.lookup_rw(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Converts the subtree to a collection of key/value string pairs. /// /// \param [out] properties The accumulator for the generated properties. The /// contents of the map are only extended. /// \param key The path to the current node. void config::detail::inner_node::all_properties(properties_map& properties, const tree_key& key) const { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { tree_key child_key = key; child_key.push_back((*iter).first); try { leaf_node& child = dynamic_cast< leaf_node& >(*(*iter).second); if (child.is_set()) properties[flatten_key(child_key)] = child.to_string(); } catch (const std::bad_cast& unused_error) { inner_node& child = dynamic_cast< inner_node& >(*(*iter).second); child.all_properties(properties, child_key); } } } /// Constructor. config::detail::static_inner_node::static_inner_node(void) : inner_node(false) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::static_inner_node::deep_copy(void) const { std::auto_ptr< inner_node > new_node(new static_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Registers a key as valid and having a specific type. /// /// This method does not raise errors on invalid/unknown keys or other /// tree-related issues. The reasons is that define() is a method that does not /// depend on user input: it is intended to pre-populate the tree with a /// specific structure, and that happens once at coding time. /// /// \param key The key to be registered. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. void config::detail::static_inner_node::define(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); if (key_pos == key.size() - 1) { PRE_MSG(_children.find(key[key_pos]) == _children.end(), "Key already defined"); _children.insert(children_map::value_type(key[key_pos], new_node())); } else { PRE(key_pos < key.size() - 1); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) { static_inner_node* const child_ptr = new static_inner_node(); _children.insert(children_map::value_type(key[key_pos], child_ptr)); child_ptr->define(key, key_pos + 1, new_node); } else { try { static_inner_node& child = dynamic_cast< static_inner_node& >( *(*child_iter).second); child.define(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { UNREACHABLE; } } } } /// Constructor. config::detail::dynamic_inner_node::dynamic_inner_node(void) : inner_node(true) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::dynamic_inner_node::deep_copy(void) const { std::auto_ptr< inner_node > new_node(new dynamic_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Destructor. config::leaf_node::~leaf_node(void) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::bool_node::deep_copy(void) const { std::auto_ptr< bool_node > new_node(new bool_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::bool_node::push_lua(lutok::state& state) const { state.push_boolean(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::bool_node::set_lua(lutok::state& state, const int value_index) { if (state.is_boolean(value_index)) set(state.to_boolean(value_index)); else throw value_error("Not a boolean"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::int_node::deep_copy(void) const { std::auto_ptr< int_node > new_node(new int_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::int_node::push_lua(lutok::state& state) const { state.push_integer(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::int_node::set_lua(lutok::state& state, const int value_index) { if (state.is_number(value_index)) set(state.to_integer(value_index)); else throw value_error("Not an integer"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::string_node::deep_copy(void) const { std::auto_ptr< string_node > new_node(new string_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::string_node::push_lua(lutok::state& state) const { state.push_string(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::string_node::set_lua(lutok::state& state, const int value_index) { if (state.is_string(value_index)) set(state.to_string(value_index)); else throw value_error("Not a string"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::strings_set_node::deep_copy(void) const { std::auto_ptr< strings_set_node > new_node(new strings_set_node()); new_node->_value = _value; return new_node.release(); } /// Converts a single word to the native type. /// /// \param raw_value The value to parse. /// /// \return The parsed value. std::string config::strings_set_node::parse_one(const std::string& raw_value) const { return raw_value; } @ 1.1.1.1.4.1 log @file nodes.cpp was added on branch tls-maxphys on 2013-02-25 00:26:15 +0000 @ text @d1 439 @ 1.1.1.1.4.2 log @resync with head @ text @a0 439 // Copyright 2012 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/config/nodes.ipp" #include #include #include "utils/config/exceptions.hpp" #include "utils/config/keys.hpp" #include "utils/format/macros.hpp" namespace config = utils::config; /// Destructor. config::detail::base_node::~base_node(void) { } /// Constructor. /// /// \param dynamic_ Whether the node is dynamic or not. config::detail::inner_node::inner_node(const bool dynamic_) : _dynamic(dynamic_) { } /// Destructor. config::detail::inner_node::~inner_node(void) { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) delete (*iter).second; } /// Fills the given node with a copy of this node's data. /// /// \param node The node to fill. Should be the fresh return value of a /// deep_copy() operation. void config::detail::inner_node::copy_into(inner_node* node) const { node->_dynamic = _dynamic; for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { base_node* new_node = (*iter).second->deep_copy(); try { node->_children[(*iter).first] = new_node; } catch (...) { delete new_node; throw; } } } /// Finds a node without creating it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key. /// The returned node is constant, so this can only be used for querying /// purposes. For this reason, this algorithm does not create intermediate /// nodes if they don't exist (as would be necessary to set a new node). /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. const config::detail::base_node* config::detail::inner_node::lookup_ro(const tree_key& key, const tree_key::size_type key_pos) const { PRE(key_pos < key.size()); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) throw unknown_key_error(key); if (key_pos == key.size() - 1) { return (*child_iter).second; } else { PRE(key_pos < key.size() - 1); try { const inner_node& child = dynamic_cast< const inner_node& >( *(*child_iter).second); return child.lookup_ro(key, key_pos + 1); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Finds a node and creates it if not found. /// /// This recursive algorithm traverses the tree searching for a particular key, /// creating any intermediate nodes if they do not already exist (for the case /// of dynamic inner nodes). The returned node is non-constant, so this can be /// used by the algorithms that set key values. /// /// \param key The key to be queried. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. This is only called if the leaf cannot be found, but it has /// already been defined. /// /// \return A reference to the located node, if successful. /// /// \throw unknown_key_error If the provided key is unknown. /// \throw value_error If the resulting node of the search would be an inner /// node. config::leaf_node* config::detail::inner_node::lookup_rw(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); children_map::const_iterator child_iter = _children.find(key[key_pos]); if (child_iter == _children.end()) { if (_dynamic) { base_node* const child = (key_pos == key.size() - 1) ? static_cast< base_node* >(new_node()) : static_cast< base_node* >(new dynamic_inner_node()); _children.insert(children_map::value_type(key[key_pos], child)); child_iter = _children.find(key[key_pos]); } else { throw unknown_key_error(key); } } if (key_pos == key.size() - 1) { try { leaf_node& child = dynamic_cast< leaf_node& >( *(*child_iter).second); return &child; } catch (const std::bad_cast& unused_error) { throw value_error(F("Invalid value for key '%s'") % flatten_key(key)); } } else { PRE(key_pos < key.size() - 1); try { inner_node& child = dynamic_cast< inner_node& >( *(*child_iter).second); return child.lookup_rw(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { throw unknown_key_error( key, "Cannot address incomplete configuration property '%s'"); } } } /// Converts the subtree to a collection of key/value string pairs. /// /// \param [out] properties The accumulator for the generated properties. The /// contents of the map are only extended. /// \param key The path to the current node. void config::detail::inner_node::all_properties(properties_map& properties, const tree_key& key) const { for (children_map::const_iterator iter = _children.begin(); iter != _children.end(); ++iter) { tree_key child_key = key; child_key.push_back((*iter).first); try { leaf_node& child = dynamic_cast< leaf_node& >(*(*iter).second); if (child.is_set()) properties[flatten_key(child_key)] = child.to_string(); } catch (const std::bad_cast& unused_error) { inner_node& child = dynamic_cast< inner_node& >(*(*iter).second); child.all_properties(properties, child_key); } } } /// Constructor. config::detail::static_inner_node::static_inner_node(void) : inner_node(false) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::static_inner_node::deep_copy(void) const { std::auto_ptr< inner_node > new_node(new static_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Registers a key as valid and having a specific type. /// /// This method does not raise errors on invalid/unknown keys or other /// tree-related issues. The reasons is that define() is a method that does not /// depend on user input: it is intended to pre-populate the tree with a /// specific structure, and that happens once at coding time. /// /// \param key The key to be registered. /// \param key_pos The current level within the key to be examined. /// \param new_node A function that returns a new leaf node of the desired /// type. void config::detail::static_inner_node::define(const tree_key& key, const tree_key::size_type key_pos, new_node_hook new_node) { PRE(key_pos < key.size()); if (key_pos == key.size() - 1) { PRE_MSG(_children.find(key[key_pos]) == _children.end(), "Key already defined"); _children.insert(children_map::value_type(key[key_pos], new_node())); } else { PRE(key_pos < key.size() - 1); const children_map::const_iterator child_iter = _children.find( key[key_pos]); if (child_iter == _children.end()) { static_inner_node* const child_ptr = new static_inner_node(); _children.insert(children_map::value_type(key[key_pos], child_ptr)); child_ptr->define(key, key_pos + 1, new_node); } else { try { static_inner_node& child = dynamic_cast< static_inner_node& >( *(*child_iter).second); child.define(key, key_pos + 1, new_node); } catch (const std::bad_cast& e) { UNREACHABLE; } } } } /// Constructor. config::detail::dynamic_inner_node::dynamic_inner_node(void) : inner_node(true) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::detail::dynamic_inner_node::deep_copy(void) const { std::auto_ptr< inner_node > new_node(new dynamic_inner_node()); copy_into(new_node.get()); return new_node.release(); } /// Destructor. config::leaf_node::~leaf_node(void) { } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::bool_node::deep_copy(void) const { std::auto_ptr< bool_node > new_node(new bool_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::bool_node::push_lua(lutok::state& state) const { state.push_boolean(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::bool_node::set_lua(lutok::state& state, const int value_index) { if (state.is_boolean(value_index)) set(state.to_boolean(value_index)); else throw value_error("Not a boolean"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::int_node::deep_copy(void) const { std::auto_ptr< int_node > new_node(new int_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::int_node::push_lua(lutok::state& state) const { state.push_integer(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::int_node::set_lua(lutok::state& state, const int value_index) { if (state.is_number(value_index)) set(state.to_integer(value_index)); else throw value_error("Not an integer"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::string_node::deep_copy(void) const { std::auto_ptr< string_node > new_node(new string_node()); new_node->_value = _value; return new_node.release(); } /// Pushes the node's value onto the Lua stack. /// /// \param state The Lua state onto which to push the value. void config::string_node::push_lua(lutok::state& state) const { state.push_string(value()); } /// Sets the value of the node from an entry in the Lua stack. /// /// \param state The Lua state from which to get the value. /// \param value_index The stack index in which the value resides. /// /// \throw value_error If the value in state(value_index) cannot be /// processed by this node. void config::string_node::set_lua(lutok::state& state, const int value_index) { if (state.is_string(value_index)) set(state.to_string(value_index)); else throw value_error("Not a string"); } /// Copies the node. /// /// \return A dynamically-allocated node. config::detail::base_node* config::strings_set_node::deep_copy(void) const { std::auto_ptr< strings_set_node > new_node(new strings_set_node()); new_node->_value = _value; return new_node.release(); } /// Converts a single word to the native type. /// /// \param raw_value The value to parse. /// /// \return The parsed value. std::string config::strings_set_node::parse_one(const std::string& raw_value) const { return raw_value; } @