LocalInventoryEp.hpp

 
#pragma once
#ifndef GI_INV_LOCALINVENTORYEP_HPP
#define GI_INV_LOCALINVENTORYEP_HPP
 
#include <boost/optional.hpp>
#include "opflex/modb/URIBuilder.h"
#include "opflex/modb/mo-internal/MO.h"
/*
 * contains: item:mclass(inv/LocalInventoryEpToGroupRSrc)
 */
#include "modelgbp/inv/LocalInventoryEpToGroupRSrc.hpp"
/*
 * contains: item:mclass(inv/LocalInventoryEpToSecGroupRSrc)
 */
#include "modelgbp/inv/LocalInventoryEpToSecGroupRSrc.hpp"
/*
 * contains: item:mclass(inv/Ip)
 */
#include "modelgbp/inv/Ip.hpp"
/*
 * contains: item:mclass(inv/IpMapping)
 */
#include "modelgbp/inv/IpMapping.hpp"
/*
 * contains: item:mclass(inv/Interface)
 */
#include "modelgbp/inv/Interface.hpp"
/*
 * contains: item:mclass(inv/DHCPv4Config)
 */
#include "modelgbp/inv/DHCPv4Config.hpp"
/*
 * contains: item:mclass(inv/DHCPv6Config)
 */
#include "modelgbp/inv/DHCPv6Config.hpp"
/*
 * contains: item:mclass(inv/Attribute)
 */
#include "modelgbp/inv/Attribute.hpp"
 
namespace modelgbp {
namespace inv {
 
class LocalInventoryEp
    : public opflex::modb::mointernal::MO
{
public:
 
    static const opflex::modb::class_id_t CLASS_ID = 116;
 
    bool isAccessVlanSet()
    {
        return getObjectInstance().isSet(3801092ul, opflex::modb::PropertyInfo::U64);
    }
 
    boost::optional<uint16_t> getAccessVlan()
    {
        if (isAccessVlanSet())
            return (uint16_t)getObjectInstance().getUInt64(3801092ul);
        return boost::none;
    }
 
    uint16_t getAccessVlan(uint16_t defaultValue)
    {
        return getAccessVlan().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setAccessVlan(uint16_t newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setUInt64(3801092ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetAccessVlan()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801092ul, opflex::modb::PropertyInfo::U64, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isDiscoveryModeSet()
    {
        return getObjectInstance().isSet(3801094ul, opflex::modb::PropertyInfo::ENUM8);
    }
 
    boost::optional<const uint8_t> getDiscoveryMode()
    {
        if (isDiscoveryModeSet())
            return (const uint8_t)getObjectInstance().getUInt64(3801094ul);
        return boost::none;
    }
 
    const uint8_t getDiscoveryMode(const uint8_t defaultValue)
    {
        return getDiscoveryMode().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setDiscoveryMode(const uint8_t newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setUInt64(3801094ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetDiscoveryMode()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801094ul, opflex::modb::PropertyInfo::ENUM8, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isEgMappingAliasSet()
    {
        return getObjectInstance().isSet(3801091ul, opflex::modb::PropertyInfo::STRING);
    }
 
    boost::optional<const std::string&> getEgMappingAlias()
    {
        if (isEgMappingAliasSet())
            return getObjectInstance().getString(3801091ul);
        return boost::none;
    }
 
    const std::string& getEgMappingAlias(const std::string& defaultValue)
    {
        return getEgMappingAlias().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setEgMappingAlias(const std::string& newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setString(3801091ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetEgMappingAlias()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801091ul, opflex::modb::PropertyInfo::STRING, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isIfaceSecuritySet()
    {
        return getObjectInstance().isSet(3801093ul, opflex::modb::PropertyInfo::ENUM8);
    }
 
    boost::optional<const uint8_t> getIfaceSecurity()
    {
        if (isIfaceSecuritySet())
            return (const uint8_t)getObjectInstance().getUInt64(3801093ul);
        return boost::none;
    }
 
    const uint8_t getIfaceSecurity(const uint8_t defaultValue)
    {
        return getIfaceSecurity().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setIfaceSecurity(const uint8_t newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setUInt64(3801093ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetIfaceSecurity()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801093ul, opflex::modb::PropertyInfo::ENUM8, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isMacSet()
    {
        return getObjectInstance().isSet(3801090ul, opflex::modb::PropertyInfo::MAC);
    }
 
    boost::optional<const opflex::modb::MAC&> getMac()
    {
        if (isMacSet())
            return getObjectInstance().getMAC(3801090ul);
        return boost::none;
    }
 
    const opflex::modb::MAC& getMac(const opflex::modb::MAC& defaultValue)
    {
        return getMac().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setMac(const opflex::modb::MAC& newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setMAC(3801090ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetMac()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801090ul, opflex::modb::PropertyInfo::MAC, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isUuidSet()
    {
        return getObjectInstance().isSet(3801089ul, opflex::modb::PropertyInfo::STRING);
    }
 
    boost::optional<const std::string&> getUuid()
    {
        if (isUuidSet())
            return getObjectInstance().getString(3801089ul);
        return boost::none;
    }
 
    const std::string& getUuid(const std::string& defaultValue)
    {
        return getUuid().get_value_or(defaultValue);
    }
 
    modelgbp::inv::LocalInventoryEp& setUuid(const std::string& newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setString(3801089ul, newValue);
        return *this;
    }
 
    modelgbp::inv::LocalInventoryEp& unsetUuid()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(3801089ul, opflex::modb::PropertyInfo::STRING, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEp> > resolve(
        opflex::ofcore::OFFramework& framework,
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::inv::LocalInventoryEp>(framework, CLASS_ID, uri);
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEp> > resolve(
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::inv::LocalInventoryEp>(opflex::ofcore::OFFramework::defaultInstance(), CLASS_ID, uri);
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEp> > resolve(
        opflex::ofcore::OFFramework& framework,
        const std::string& invLocalEndpointInventoryName,
        const std::string& invLocalInventoryEpUuid)
    {
        return resolve(framework,opflex::modb::URIBuilder().addElement("InvUniverse").addElement("InvLocalEndpointInventory").addElement(invLocalEndpointInventoryName).addElement("InvLocalInventoryEp").addElement(invLocalInventoryEpUuid).build());
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEp> > resolve(
        const std::string& invLocalEndpointInventoryName,
        const std::string& invLocalInventoryEpUuid)
    {
        return resolve(opflex::ofcore::OFFramework::defaultInstance(),invLocalEndpointInventoryName,invLocalInventoryEpUuid);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToGroupRSrc> > resolveInvLocalInventoryEpToGroupRSrc(
        )
    {
        return modelgbp::inv::LocalInventoryEpToGroupRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpToGroupRSrc").build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToGroupRSrc> addInvLocalInventoryEpToGroupRSrc(
        )
    {
        OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToGroupRSrc> result = addChild<modelgbp::inv::LocalInventoryEpToGroupRSrc>(
            CLASS_ID, getURI(), 2151284853ul, 117,
            opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpToGroupRSrc").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToSecGroupRSrc> > resolveInvLocalInventoryEpToSecGroupRSrc(
        const std::string& invLocalInventoryEpToSecGroupRSrcTargetName)
    {
        opflex::modb::class_id_t invLocalInventoryEpToSecGroupRSrcTargetClass = 203;
        return modelgbp::inv::LocalInventoryEpToSecGroupRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpToSecGroupRSrc").addElement(invLocalInventoryEpToSecGroupRSrcTargetClass).addElement(invLocalInventoryEpToSecGroupRSrcTargetName).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToSecGroupRSrc> addInvLocalInventoryEpToSecGroupRSrc(
        const std::string& invLocalInventoryEpToSecGroupRSrcTargetName)
    {
        opflex::modb::class_id_t invLocalInventoryEpToSecGroupRSrcTargetClass = 203;
        OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToSecGroupRSrc> result = addChild<modelgbp::inv::LocalInventoryEpToSecGroupRSrc>(
            CLASS_ID, getURI(), 2151284856ul, 120,
            opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpToSecGroupRSrc").addElement(invLocalInventoryEpToSecGroupRSrcTargetClass).addElement(invLocalInventoryEpToSecGroupRSrcTargetName).build()
            );
        result->setTargetSecGroup(opflex::modb::URI(invLocalInventoryEpToSecGroupRSrcTargetName));
        return result;
    }
 
    void resolveInvLocalInventoryEpToSecGroupRSrc(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpToSecGroupRSrc> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::LocalInventoryEpToSecGroupRSrc>(
            getFramework(), CLASS_ID, getURI(), 2151284856ul, 120, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::Ip> > resolveInvIp(
        const std::string& invIpIp,
        const std::string& invIpType)
    {
        return modelgbp::inv::Ip::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvIp").addElement(invIpIp).addElement(invIpType).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::Ip> addInvIp(
        const std::string& invIpIp,
        const std::string& invIpType)
    {
        OF_SHARED_PTR<modelgbp::inv::Ip> result = addChild<modelgbp::inv::Ip>(
            CLASS_ID, getURI(), 2151284859ul, 123,
            opflex::modb::URIBuilder(getURI()).addElement("InvIp").addElement(invIpIp).addElement(invIpType).build()
            );
        result->setIp(invIpIp);
        result->setType(invIpType);
        return result;
    }
 
    void resolveInvIp(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::Ip> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::Ip>(
            getFramework(), CLASS_ID, getURI(), 2151284859ul, 123, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::IpMapping> > resolveInvIpMapping(
        const std::string& invIpMappingName)
    {
        return modelgbp::inv::IpMapping::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvIpMapping").addElement(invIpMappingName).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::IpMapping> addInvIpMapping(
        const std::string& invIpMappingName)
    {
        OF_SHARED_PTR<modelgbp::inv::IpMapping> result = addChild<modelgbp::inv::IpMapping>(
            CLASS_ID, getURI(), 2151284860ul, 124,
            opflex::modb::URIBuilder(getURI()).addElement("InvIpMapping").addElement(invIpMappingName).build()
            );
        result->setName(invIpMappingName);
        return result;
    }
 
    void resolveInvIpMapping(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::IpMapping> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::IpMapping>(
            getFramework(), CLASS_ID, getURI(), 2151284860ul, 124, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::Interface> > resolveInvInterface(
        const std::string& invInterfaceName,
        const std::string& invInterfaceType)
    {
        return modelgbp::inv::Interface::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvInterface").addElement(invInterfaceName).addElement(invInterfaceType).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::Interface> addInvInterface(
        const std::string& invInterfaceName,
        const std::string& invInterfaceType)
    {
        OF_SHARED_PTR<modelgbp::inv::Interface> result = addChild<modelgbp::inv::Interface>(
            CLASS_ID, getURI(), 2151284864ul, 128,
            opflex::modb::URIBuilder(getURI()).addElement("InvInterface").addElement(invInterfaceName).addElement(invInterfaceType).build()
            );
        result->setName(invInterfaceName);
        result->setType(invInterfaceType);
        return result;
    }
 
    void resolveInvInterface(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::Interface> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::Interface>(
            getFramework(), CLASS_ID, getURI(), 2151284864ul, 128, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::DHCPv4Config> > resolveInvDHCPv4Config(
        )
    {
        return modelgbp::inv::DHCPv4Config::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvDHCPv4Config").build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::DHCPv4Config> addInvDHCPv4Config(
        )
    {
        OF_SHARED_PTR<modelgbp::inv::DHCPv4Config> result = addChild<modelgbp::inv::DHCPv4Config>(
            CLASS_ID, getURI(), 2151284866ul, 130,
            opflex::modb::URIBuilder(getURI()).addElement("InvDHCPv4Config").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::DHCPv6Config> > resolveInvDHCPv6Config(
        )
    {
        return modelgbp::inv::DHCPv6Config::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvDHCPv6Config").build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::DHCPv6Config> addInvDHCPv6Config(
        )
    {
        OF_SHARED_PTR<modelgbp::inv::DHCPv6Config> result = addChild<modelgbp::inv::DHCPv6Config>(
            CLASS_ID, getURI(), 2151284870ul, 134,
            opflex::modb::URIBuilder(getURI()).addElement("InvDHCPv6Config").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::Attribute> > resolveInvAttribute(
        const std::string& invAttributeName)
    {
        return modelgbp::inv::Attribute::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvAttribute").addElement(invAttributeName).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::Attribute> addInvAttribute(
        const std::string& invAttributeName)
    {
        OF_SHARED_PTR<modelgbp::inv::Attribute> result = addChild<modelgbp::inv::Attribute>(
            CLASS_ID, getURI(), 2151284872ul, 136,
            opflex::modb::URIBuilder(getURI()).addElement("InvAttribute").addElement(invAttributeName).build()
            );
        result->setName(invAttributeName);
        return result;
    }
 
    void resolveInvAttribute(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::Attribute> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::Attribute>(
            getFramework(), CLASS_ID, getURI(), 2151284872ul, 136, out);
    }
 
    void remove()
    {
        getTLMutator().remove(CLASS_ID, getURI());
    }
 
    static void remove(opflex::ofcore::OFFramework& framework,
                       const opflex::modb::URI& uri)
    {
        MO::remove(framework, CLASS_ID, uri);
    }
 
    static void remove(const opflex::modb::URI& uri)
    {
        remove(opflex::ofcore::OFFramework::defaultInstance(), uri);
    }
 
    static void remove(
        opflex::ofcore::OFFramework& framework,
        const std::string& invLocalEndpointInventoryName,
        const std::string& invLocalInventoryEpUuid)
    {
        MO::remove(framework, CLASS_ID, opflex::modb::URIBuilder().addElement("InvUniverse").addElement("InvLocalEndpointInventory").addElement(invLocalEndpointInventoryName).addElement("InvLocalInventoryEp").addElement(invLocalInventoryEpUuid).build());
    }
 
    static void remove(
        const std::string& invLocalEndpointInventoryName,
        const std::string& invLocalInventoryEpUuid)
    {
        remove(opflex::ofcore::OFFramework::defaultInstance(),invLocalEndpointInventoryName,invLocalInventoryEpUuid);
    }
 
    static void registerListener(
        opflex::ofcore::OFFramework& framework,
        opflex::modb::ObjectListener* listener)
    {
        opflex::modb::mointernal
            ::MO::registerListener(framework, listener, CLASS_ID);
    }
 
    static void registerListener(
        opflex::modb::ObjectListener* listener)
    {
        registerListener(opflex::ofcore::OFFramework::defaultInstance(), listener);
    }
 
    static void unregisterListener(
        opflex::ofcore::OFFramework& framework,
        opflex::modb::ObjectListener* listener)
    {
        opflex::modb::mointernal
            ::MO::unregisterListener(framework, listener, CLASS_ID);
    }
 
    static void unregisterListener(
        opflex::modb::ObjectListener* listener)
    {
        unregisterListener(opflex::ofcore::OFFramework::defaultInstance(), listener);
    }
 
    LocalInventoryEp(
        opflex::ofcore::OFFramework& framework,
        const opflex::modb::URI& uri,
        const OF_SHARED_PTR<const opflex::modb::mointernal::ObjectInstance>& oi)
        : MO(framework, CLASS_ID, uri, oi) { }
}; // class LocalInventoryEp
 
} // namespace inv
} // namespace modelgbp
#endif // GI_INV_LOCALINVENTORYEP_HPP