host_container.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef HOST_CONTAINER_H
#define HOST_CONTAINER_H
 
#include <dhcpsrv/host.h>
#include <dhcpsrv/subnet_id.h>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
 
namespace isc {
namespace dhcp {
 
typedef boost::multi_index_container<
    // This container stores pointers to Host objects.
    HostPtr,
    // Start specification of indexes here.
    boost::multi_index::indexed_by<
        // First index is used to search for the host using one of the
        // identifiers, i.e. HW address or DUID. The elements of this
        // index are non-unique because there may be multiple reservations
        // for the same host belonging to a different subnets.
        boost::multi_index::ordered_non_unique<
            // The index comprises actual identifier (HW address or DUID) in
            // a binary form and a type of the identifier which indicates
            // that it is HW address or DUID.
            boost::multi_index::composite_key<
                // Composite key uses members of the Host class.
                Host,
                // Binary identifier is retrieved from the Host class using
                // a getIdentifier method.
                boost::multi_index::const_mem_fun<
                    Host, const std::vector<uint8_t>&,
                    &Host::getIdentifier
                >,
                // Identifier type is retrieved from the Host class using
                // a getIdentifierType method.
                boost::multi_index::const_mem_fun<
                    Host, Host::IdentifierType,
                    &Host::getIdentifierType
                >
            >
        >,
 
        // Second index is used to search for the host using reserved IPv4
        // address.
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getIPv4Reservation.
            boost::multi_index::const_mem_fun<Host, const asiolink::IOAddress&,
                                               &Host::getIPv4Reservation>
        >,
 
        // Third index is used to search for the host using IPv4 subnet id
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getIPv4SubnetID
            boost::multi_index::const_mem_fun<Host, SubnetID,
                                              &Host::getIPv4SubnetID>
        >,
 
        // Forth index is used to search for the host using IPv6 subnet id
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getIPv6SubnetID
            boost::multi_index::const_mem_fun<Host, SubnetID,
                                              &Host::getIPv6SubnetID>
        >,
 
        // Fifth index is used to search by increasing host id
        boost::multi_index::ordered_unique<
            // Index using values returned by the @c Host::getHostId
            boost::multi_index::const_mem_fun<Host, uint64_t,
                                              &Host::getHostId>
        >,
 
        // Sixth index is used to search for the host using hostname
        // (case-sensitive compare so the key is in lower case).
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getLowerHostname
            boost::multi_index::const_mem_fun<Host, std::string,
                                              &Host::getLowerHostname>
        >
    >
> HostContainer;
 
typedef HostContainer::nth_index<0>::type HostContainerIndex0;
 
typedef std::pair<HostContainerIndex0::iterator,
                  HostContainerIndex0::iterator> HostContainerIndex0Range;
 
typedef HostContainer::nth_index<1>::type HostContainerIndex1;
 
typedef std::pair<HostContainerIndex1::iterator,
                  HostContainerIndex1::iterator> HostContainerIndex1Range;
 
typedef HostContainer::nth_index<2>::type HostContainerIndex2;
 
typedef std::pair<HostContainerIndex2::iterator,
                  HostContainerIndex2::iterator> HostContainerIndex2Range;
 
typedef HostContainer::nth_index<3>::type HostContainerIndex3;
 
typedef std::pair<HostContainerIndex3::iterator,
                  HostContainerIndex3::iterator> HostContainerIndex3Range;
 
typedef HostContainer::nth_index<4>::type HostContainerIndex4;
 
typedef std::pair<HostContainerIndex4::iterator,
                  HostContainerIndex4::iterator> HostContainerIndex4Range;
 
typedef HostContainer::nth_index<5>::type HostContainerIndex5;
 
struct HostResrv6Tuple {
 
    HostResrv6Tuple(const IPv6Resrv& resrv, const HostPtr& host)
    : resrv_(resrv), host_(host), subnet_id_(host ? host->getIPv6SubnetID() : SUBNET_ID_GLOBAL) {
    }
 
    const IPv6Resrv resrv_;
 
    HostPtr host_;
 
    const SubnetID subnet_id_;
 
    const asiolink::IOAddress& getPrefix() const {
        return (resrv_.getPrefix());
    }
 
    HostID getHostId() const {
        return (host_->getHostId());
    }
};
 
typedef boost::multi_index_container<
 
    // This containers stores (IPv6Resrv, HostPtr) tuples
    HostResrv6Tuple,
 
    // Start specification of indexes here.
    boost::multi_index::indexed_by<
 
        // First index is used to search by an address.
        boost::multi_index::ordered_non_unique<
 
            // Address is extracted by calling IPv6Resrv::getPrefix()
            // and it will return an IOAddress object.
            boost::multi_index::const_mem_fun<
                HostResrv6Tuple, const asiolink::IOAddress&, &HostResrv6Tuple::getPrefix>
        >,
 
        // Second index is used to search by (subnet_id, address) pair.
        // This is
        boost::multi_index::ordered_non_unique<
 
            boost::multi_index::composite_key<
 
                // Composite key uses members of the HostResrv6Tuple class.
                HostResrv6Tuple,
 
                // First key extractor. Gets subnet-id as a member of the
                // HostResrv6Tuple structure.
                boost::multi_index::member<HostResrv6Tuple, const SubnetID,
                    &HostResrv6Tuple::subnet_id_>,
 
                // Second key extractor. Address is extracted by calling
                // IPv6Resrv::getPrefix() and it will return an IOAddress object.
                boost::multi_index::const_mem_fun<
                    HostResrv6Tuple, const asiolink::IOAddress&,
                    &HostResrv6Tuple::getPrefix
                >
           >
        >,
 
        // Third index is used to search for the host using IPv6 subnet id
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getIPv6SubnetID
            boost::multi_index::member<HostResrv6Tuple, const SubnetID,
                                       &HostResrv6Tuple::subnet_id_>
        >,
 
        // Fourth index is used to search by increasing host id
        boost::multi_index::ordered_non_unique<
            // Index using values returned by the @c Host::getHostId
            boost::multi_index::const_mem_fun<HostResrv6Tuple, uint64_t,
                                              &HostResrv6Tuple::getHostId>
        >,
 
        // Fifth index is used to search by the reserved address.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::const_mem_fun<
                HostResrv6Tuple, const asiolink::IOAddress&,
                &HostResrv6Tuple::getPrefix
            >
        >
    >
> HostContainer6;
 
typedef HostContainer6::nth_index<0>::type HostContainer6Index0;
 
typedef std::pair<HostContainer6Index0::iterator,
                  HostContainer6Index0::iterator> HostContainer6Index0Range;
 
typedef HostContainer6::nth_index<1>::type HostContainer6Index1;
 
typedef std::pair<HostContainer6Index1::iterator,
                  HostContainer6Index1::iterator> HostContainer6Index1Range;
 
typedef HostContainer6::nth_index<2>::type HostContainer6Index2;
 
typedef std::pair<HostContainer6Index2::iterator,
                  HostContainer6Index2::iterator> HostContainer6Index2Range;
 
typedef HostContainer6::nth_index<3>::type HostContainer6Index3;
 
typedef std::pair<HostContainer6Index3::iterator,
                  HostContainer6Index3::iterator> HostContainer6Index3Range;
 
typedef HostContainer6::nth_index<4>::type HostContainer6Index4;
 
typedef std::pair<HostContainer6Index4::iterator,
                  HostContainer6Index4::iterator> HostContainer6Index4Range;
 
}  // namespace dhcp
}  // namespace isc
 
#endif // HOST_CONTAINER_H