if HAVE_MYSQL
libb10_dhcpsrv_la_SOURCES += mysql_lease_mgr.cc mysql_lease_mgr.h
endif
+libb10_dhcpsrv_la_SOURCES += option_space_container.h
libb10_dhcpsrv_la_SOURCES += pool.cc pool.h
libb10_dhcpsrv_la_SOURCES += subnet.cc subnet.h
libb10_dhcpsrv_la_SOURCES += triplet.h
<< option_space << "'.");
}
- // Get existing option definitions for the option space.
- OptionDefContainerPtr defs = getOptionDefs(option_space);
- // getOptionDefs always returns a valid pointer to
- // the container. Let's make an assert to make sure.
- assert(defs);
- // Actually add the new definition.
- defs->push_back(def);
- option_def_spaces_[option_space] = defs;
+ // Actually add a new item.
+ option_def_spaces_.addItem(def, option_space);
}
OptionDefContainerPtr
CfgMgr::getOptionDefs(const std::string& option_space) const {
// @todo Validate the option space once the #2313 is implemented.
- // Get all option definitions for the particular option space.
- const OptionDefsMap::const_iterator& defs =
- option_def_spaces_.find(option_space);
- // If there are no option definitions for the particular option space
- // then return empty container.
- if (defs == option_def_spaces_.end()) {
- return (OptionDefContainerPtr(new OptionDefContainer()));
- }
- // If option definitions found, return them.
- return (defs->second);
+ return (option_def_spaces_.getItems(option_space));
}
OptionDefinitionPtr
}
void CfgMgr::deleteOptionDefs() {
- option_def_spaces_.clear();
+ option_def_spaces_.clearItems();
}
void CfgMgr::deleteSubnets4() {
#include <asiolink/io_address.h>
#include <dhcp/option.h>
#include <dhcp/option_definition.h>
+#include <dhcpsrv/option_space_container.h>
#include <dhcpsrv/pool.h>
#include <dhcpsrv/subnet.h>
#include <util/buffer.h>
private:
- /// A map containing option definitions for various option spaces.
- /// They key of this map is the name of the option space. The
- /// value is the the option container holding option definitions
- /// for the particular option space.
- typedef std::map<std::string, OptionDefContainerPtr> OptionDefsMap;
+ /// A collection of option definitions accessible with option
+ /// space name.
+ typedef OptionSpaceContainer<OptionDefContainer,
+ OptionDefinitionPtr> OptionSpaceCollection;
- /// A map containing option definitions for different option spaces.
- /// The map key holds an option space name.
- OptionDefsMap option_def_spaces_;
+ OptionSpaceCollection option_def_spaces_;
};
--- /dev/null
+// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef OPTION_SPACE_CONTAINER_H
+#define OPTION_SPACE_CONTAINER_H
+
+namespace isc {
+namespace dhcp {
+
+/// @brief Simple container for option spaces holding various items.
+///
+/// This helper class is used to store items of various types in
+/// that are grouped by option space names. Each option space is
+/// mapped to a container that holds items which specifically can
+/// be OptionDefinition objects or Subnet::OptionDescriptor structures.
+///
+/// @tparam ContainerType of the container holding items within
+/// option space.
+/// @tparam ItemType type of the item being held by the container.
+template<typename ContainerType, typename ItemType>
+class OptionSpaceContainer {
+public:
+
+ /// Pointer to the container.
+ typedef boost::shared_ptr<ContainerType> ItemsContainerPtr;
+
+ /// @brief Adds a new item to the option_space.
+ ///
+ /// @param item reference to the item being added.
+ /// @param name of the option space.
+ void addItem(const ItemType& item, const std::string& option_space) {
+ ItemsContainerPtr items = getItems(option_space);
+ items->push_back(item);
+ option_space_map_[option_space] = items;
+ }
+
+ /// @brief Get all items for the particular option space.
+ ///
+ /// @param option_space name of the option space.
+ ///
+ /// @return pointer to the container holding items.
+ ItemsContainerPtr getItems(const std::string& option_space) const {
+ const typename OptionSpaceMap::const_iterator& items =
+ option_space_map_.find(option_space);
+ if (items == option_space_map_.end()) {
+ return (ItemsContainerPtr(new ContainerType()));
+ }
+ return (items->second);
+ }
+
+ /// @brief Remove all items from the container.
+ void clearItems() {
+ option_space_map_.clear();
+ }
+
+private:
+
+ /// A map holding container (option space name is the key).
+ typedef std::map<std::string, ItemsContainerPtr> OptionSpaceMap;
+ OptionSpaceMap option_space_map_;
+};
+
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
+
+#endif // OPTION_SPACE_CONTAINER_H
}
validateOption(option);
- OptionContainerPtr container = getOptionDescriptors(option_space);
- // getOptionDescriptors is expected to return the pointer to the
- // valid container. Let's make sure it does by performing an assert.
- assert(container);
- // Actually add the new descriptor.
- container->push_back(OptionDescriptor(option, persistent));
- option_spaces_[option_space] = container;
+ // Actually add new option descriptor.
+ option_spaces_.addItem(OptionDescriptor(option, persistent), option_space);
}
void
Subnet::delOptions() {
- option_spaces_.clear();
+ option_spaces_.clearItems();
}
Subnet::OptionContainerPtr
Subnet::getOptionDescriptors(const std::string& option_space) const {
- // Search the map to get the options container for the particular
- // option space.
- const OptionSpacesPtr::const_iterator& options =
- option_spaces_.find(option_space);
- // If the option space has not been found it means that no option
- // has been configured for this option space yet. Thus we have to
- // return an empty container to the caller.
- if (options == option_spaces_.end()) {
- // The default constructor creates an empty container.
- return (OptionContainerPtr(new OptionContainer()));
- }
- // We found some option container for the option space specified.
- // Let's return a const reference to it.
- return (options->second);
+ return (option_spaces_.getItems(option_space));
}
Subnet::OptionDescriptor
#include <asiolink/io_address.h>
#include <dhcp/option.h>
+#include <dhcpsrv/option_space_container.h>
#include <dhcpsrv/pool.h>
#include <dhcpsrv/triplet.h>
private:
- /// Container holding options grouped by option space names.
- typedef std::map<std::string, OptionContainerPtr> OptionSpacesPtr;
+ /// A collection of option spaces grouping option descriptors.
+ typedef OptionSpaceContainer<OptionContainer,
+ OptionDescriptor> OptionSpaceCollection;
+ OptionSpaceCollection option_spaces_;
- /// @brief a collection of DHCP option spaces holding options
- /// configured for a subnet.
- OptionSpacesPtr option_spaces_;
};
/// @brief A configuration holder for IPv4 subnet.
projects / thirdparty / kea.git / commitdiff
