container.h

Go to the documentation of this file.

// Copyright (C) 2018-2025 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 CONTAINER_H
#define 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/sequenced_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/identity.hpp>
 
namespace isc {
namespace host_cache {

struct HostSequencedIndexTag { };

struct HostHashedIndexTag { };

struct HostIdentifierIndexTag { };

struct HostAddress4IndexTag { };

typedef boost::multi_index_container<
    // This container stores pointers to Host objects.
    dhcp::HostPtr,
    // Start specification of indexes here.
    boost::multi_index::indexed_by<
        // Sequenced index implements least-recently-used.
        boost::multi_index::sequenced<
            boost::multi_index::tag<HostSequencedIndexTag>
        >,
        // Hash index for direct retrieval.
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<HostHashedIndexTag>,
            boost::multi_index::identity<dhcp::HostPtr>
        >,
        // This 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<
            boost::multi_index::tag<HostIdentifierIndexTag>,
            // 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.
                dhcp::Host,
                // Binary identifier is retrieved from the Host class using
                // a getIdentifier method.
                boost::multi_index::const_mem_fun<
                    dhcp::Host, const std::vector<uint8_t>&,
                    &dhcp::Host::getIdentifier
                >,
                // Identifier type is retrieved from the Host class using
                // a getIdentifierType method.
                boost::multi_index::const_mem_fun<
                    dhcp::Host, dhcp::Host::IdentifierType,
                    &dhcp::Host::getIdentifierType
                >
            >
        >,
 
        // This index is used to search for the host using reserved IPv4
        // address.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<HostAddress4IndexTag>,
            // Index using values returned by the @c Host::getIPv4Reservation.
            boost::multi_index::const_mem_fun<dhcp::Host,
                                              const asiolink::IOAddress&,
                                              &dhcp::Host::getIPv4Reservation>
        >
    >
> HostContainer;

typedef HostContainer::index<HostSequencedIndexTag>::type HostContainerSequencedIndex;

typedef HostContainer::index<HostHashedIndexTag>::type HostContainerHashedIndex;

typedef HostContainer::index<HostIdentifierIndexTag>::type HostContainerIdentifierIndex;

typedef std::pair<HostContainerIdentifierIndex::iterator,
                  HostContainerIdentifierIndex::iterator> HostContainerIdentifierIndexRange;

typedef HostContainer::index<HostAddress4IndexTag>::type HostContainerAddress4Index;

typedef std::pair<HostContainerAddress4Index::iterator,
                  HostContainerAddress4Index::iterator> HostContainerAddress4IndexRange;

struct HostResrv6Tuple {

    HostResrv6Tuple(const dhcp::IPv6Resrv& resrv, const dhcp::HostPtr& host)
    : resrv_(resrv), host_(host),
      subnet_id_(host ? host->getIPv6SubnetID() : dhcp::SUBNET_ID_UNUSED) {
    }

    const dhcp::IPv6Resrv resrv_;

    dhcp::HostPtr host_;

    const dhcp::SubnetID subnet_id_;

    const asiolink::IOAddress& getKey() const {
        return (resrv_.getPrefix());
    }
};

struct Resv6AddressIndexTag { };

struct Resv6SubnetAddressIndexTag { };

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<
            boost::multi_index::tag<Resv6AddressIndexTag>,
 
            // 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::getKey>
        >,
 
        // Second index is used to search by (subnet_id, address) pair.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<Resv6SubnetAddressIndexTag>,

            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 dhcp::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::getKey
                >
           >
        >
    >
> Resv6Container;

typedef Resv6Container::index<Resv6AddressIndexTag>::type
    Resv6ContainerAddressIndex;

typedef std::pair<Resv6ContainerAddressIndex::iterator,
                  Resv6ContainerAddressIndex::iterator> Resv6ContainerAddressIndexRange;

typedef Resv6Container::index<Resv6SubnetAddressIndexTag>::type
    Resv6ContainerSubnetAddressIndex;

typedef std::pair<Resv6ContainerSubnetAddressIndex::iterator,
                  Resv6ContainerSubnetAddressIndex::iterator> Resv6ContainerSubnetAddressIndexRange;
 
}; // end of isc::dhcp namespace
}; // end of isc namespace
 
#endif // CONTAINER_H