EpGroup.hpp

 
#pragma once
#ifndef GI_GBP_EPGROUP_HPP
#define GI_GBP_EPGROUP_HPP
 
#include <boost/optional.hpp>
#include "opflex/modb/URIBuilder.h"
#include "opflex/modb/mo-internal/MO.h"
/*
 * contains: item:mclass(gbpe/EpgMappingFromDefaultGroupRTgt)
 */
#include "modelgbp/gbpe/EpgMappingFromDefaultGroupRTgt.hpp"
/*
 * contains: item:mclass(gbpe/IndirectEpgMappingFromDefaultGroupRTgt)
 */
#include "modelgbp/gbpe/IndirectEpgMappingFromDefaultGroupRTgt.hpp"
/*
 * contains: item:mclass(gbpe/MappingRuleFromGroupRTgt)
 */
#include "modelgbp/gbpe/MappingRuleFromGroupRTgt.hpp"
/*
 * contains: item:mclass(gbpe/InstContext)
 */
#include "modelgbp/gbpe/InstContext.hpp"
/*
 * contains: item:mclass(span/MemberFromRefRTgt)
 */
#include "modelgbp/span/MemberFromRefRTgt.hpp"
/*
 * contains: item:mclass(epdr/EndPointFromGroupRTgt)
 */
#include "modelgbp/epdr/EndPointFromGroupRTgt.hpp"
/*
 * contains: item:mclass(inv/LocalInventoryEpFromGroupRTgt)
 */
#include "modelgbp/inv/LocalInventoryEpFromGroupRTgt.hpp"
/*
 * contains: item:mclass(inv/IpMappingFromGroupRTgt)
 */
#include "modelgbp/inv/IpMappingFromGroupRTgt.hpp"
/*
 * contains: item:mclass(gbp/EpGroupToNetworkRSrc)
 */
#include "modelgbp/gbp/EpGroupToNetworkRSrc.hpp"
/*
 * contains: item:mclass(gbp/EpGroupToProvContractRSrc)
 */
#include "modelgbp/gbp/EpGroupToProvContractRSrc.hpp"
/*
 * contains: item:mclass(gbp/EpGroupToConsContractRSrc)
 */
#include "modelgbp/gbp/EpGroupToConsContractRSrc.hpp"
/*
 * contains: item:mclass(gbp/EpGroupToIntraContractRSrc)
 */
#include "modelgbp/gbp/EpGroupToIntraContractRSrc.hpp"
/*
 * contains: item:mclass(gbp/EpGroupToSubnetsRSrc)
 */
#include "modelgbp/gbp/EpGroupToSubnetsRSrc.hpp"
/*
 * contains: item:mclass(gbp/L3ExternalNetworkFromNatEPGroupRTgt)
 */
#include "modelgbp/gbp/L3ExternalNetworkFromNatEPGroupRTgt.hpp"
 
namespace modelgbp {
namespace gbp {
 
class EpGroup
    : public opflex::modb::mointernal::MO
{
public:
 
    static const opflex::modb::class_id_t CLASS_ID = 152;
 
    bool isIntraGroupPolicySet()
    {
        return getObjectInstance().isSet(4980738ul, opflex::modb::PropertyInfo::ENUM8);
    }
 
    boost::optional<const uint8_t> getIntraGroupPolicy()
    {
        if (isIntraGroupPolicySet())
            return (const uint8_t)getObjectInstance().getUInt64(4980738ul);
        return boost::none;
    }
 
    const uint8_t getIntraGroupPolicy(const uint8_t defaultValue)
    {
        return getIntraGroupPolicy().get_value_or(defaultValue);
    }
 
    modelgbp::gbp::EpGroup& setIntraGroupPolicy(const uint8_t newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setUInt64(4980738ul, newValue);
        return *this;
    }
 
    modelgbp::gbp::EpGroup& unsetIntraGroupPolicy()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(4980738ul, opflex::modb::PropertyInfo::ENUM8, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    bool isNameSet()
    {
        return getObjectInstance().isSet(4980737ul, opflex::modb::PropertyInfo::STRING);
    }
 
    boost::optional<const std::string&> getName()
    {
        if (isNameSet())
            return getObjectInstance().getString(4980737ul);
        return boost::none;
    }
 
    const std::string& getName(const std::string& defaultValue)
    {
        return getName().get_value_or(defaultValue);
    }
 
    modelgbp::gbp::EpGroup& setName(const std::string& newValue)
    {
        getTLMutator().modify(getClassId(), getURI())->setString(4980737ul, newValue);
        return *this;
    }
 
    modelgbp::gbp::EpGroup& unsetName()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(4980737ul, opflex::modb::PropertyInfo::STRING, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroup> > resolve(
        opflex::ofcore::OFFramework& framework,
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::gbp::EpGroup>(framework, CLASS_ID, uri);
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroup> > resolve(
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::gbp::EpGroup>(opflex::ofcore::OFFramework::defaultInstance(), CLASS_ID, uri);
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroup> > resolve(
        opflex::ofcore::OFFramework& framework,
        const std::string& policySpaceName,
        const std::string& gbpEpGroupName)
    {
        return resolve(framework,opflex::modb::URIBuilder().addElement("PolicyUniverse").addElement("PolicySpace").addElement(policySpaceName).addElement("GbpEpGroup").addElement(gbpEpGroupName).build());
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroup> > resolve(
        const std::string& policySpaceName,
        const std::string& gbpEpGroupName)
    {
        return resolve(opflex::ofcore::OFFramework::defaultInstance(),policySpaceName,gbpEpGroupName);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt> > resolveGbpeEpgMappingFromDefaultGroupRTgt(
        const std::string& gbpeEpgMappingFromDefaultGroupRTgtSource)
    {
        return modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeEpgMappingFromDefaultGroupRTgt").addElement(gbpeEpgMappingFromDefaultGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt> addGbpeEpgMappingFromDefaultGroupRTgt(
        const std::string& gbpeEpgMappingFromDefaultGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt> result = addChild<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt>(
            CLASS_ID, getURI(), 2152464396ul, 12,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeEpgMappingFromDefaultGroupRTgt").addElement(gbpeEpgMappingFromDefaultGroupRTgtSource).build()
            );
        result->setSource(gbpeEpgMappingFromDefaultGroupRTgtSource);
        return result;
    }
 
    void resolveGbpeEpgMappingFromDefaultGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbpe::EpgMappingFromDefaultGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464396ul, 12, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt> > resolveGbpeIndirectEpgMappingFromDefaultGroupRTgt(
        const std::string& gbpeIndirectEpgMappingFromDefaultGroupRTgtSource)
    {
        return modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeIndirectEpgMappingFromDefaultGroupRTgt").addElement(gbpeIndirectEpgMappingFromDefaultGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt> addGbpeIndirectEpgMappingFromDefaultGroupRTgt(
        const std::string& gbpeIndirectEpgMappingFromDefaultGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt> result = addChild<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt>(
            CLASS_ID, getURI(), 2152464400ul, 16,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeIndirectEpgMappingFromDefaultGroupRTgt").addElement(gbpeIndirectEpgMappingFromDefaultGroupRTgtSource).build()
            );
        result->setSource(gbpeIndirectEpgMappingFromDefaultGroupRTgtSource);
        return result;
    }
 
    void resolveGbpeIndirectEpgMappingFromDefaultGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbpe::IndirectEpgMappingFromDefaultGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464400ul, 16, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::MappingRuleFromGroupRTgt> > resolveGbpeMappingRuleFromGroupRTgt(
        const std::string& gbpeMappingRuleFromGroupRTgtSource)
    {
        return modelgbp::gbpe::MappingRuleFromGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeMappingRuleFromGroupRTgt").addElement(gbpeMappingRuleFromGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::MappingRuleFromGroupRTgt> addGbpeMappingRuleFromGroupRTgt(
        const std::string& gbpeMappingRuleFromGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::gbpe::MappingRuleFromGroupRTgt> result = addChild<modelgbp::gbpe::MappingRuleFromGroupRTgt>(
            CLASS_ID, getURI(), 2152464415ul, 31,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeMappingRuleFromGroupRTgt").addElement(gbpeMappingRuleFromGroupRTgtSource).build()
            );
        result->setSource(gbpeMappingRuleFromGroupRTgtSource);
        return result;
    }
 
    void resolveGbpeMappingRuleFromGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbpe::MappingRuleFromGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbpe::MappingRuleFromGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464415ul, 31, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::InstContext> > resolveGbpeInstContext(
        )
    {
        return modelgbp::gbpe::InstContext::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeInstContext").build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::InstContext> addGbpeInstContext(
        )
    {
        OF_SHARED_PTR<modelgbp::gbpe::InstContext> result = addChild<modelgbp::gbpe::InstContext>(
            CLASS_ID, getURI(), 2152464424ul, 40,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeInstContext").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::span::MemberFromRefRTgt> > resolveSpanMemberFromRefRTgt(
        const std::string& spanMemberFromRefRTgtSource)
    {
        return modelgbp::span::MemberFromRefRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("SpanMemberFromRefRTgt").addElement(spanMemberFromRefRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::span::MemberFromRefRTgt> addSpanMemberFromRefRTgt(
        const std::string& spanMemberFromRefRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::span::MemberFromRefRTgt> result = addChild<modelgbp::span::MemberFromRefRTgt>(
            CLASS_ID, getURI(), 2152464459ul, 75,
            opflex::modb::URIBuilder(getURI()).addElement("SpanMemberFromRefRTgt").addElement(spanMemberFromRefRTgtSource).build()
            );
        result->setSource(spanMemberFromRefRTgtSource);
        return result;
    }
 
    void resolveSpanMemberFromRefRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::span::MemberFromRefRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::span::MemberFromRefRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464459ul, 75, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::epdr::EndPointFromGroupRTgt> > resolveEpdrEndPointFromGroupRTgt(
        const std::string& epdrEndPointFromGroupRTgtSource)
    {
        return modelgbp::epdr::EndPointFromGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("EpdrEndPointFromGroupRTgt").addElement(epdrEndPointFromGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::epdr::EndPointFromGroupRTgt> addEpdrEndPointFromGroupRTgt(
        const std::string& epdrEndPointFromGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::epdr::EndPointFromGroupRTgt> result = addChild<modelgbp::epdr::EndPointFromGroupRTgt>(
            CLASS_ID, getURI(), 2152464488ul, 104,
            opflex::modb::URIBuilder(getURI()).addElement("EpdrEndPointFromGroupRTgt").addElement(epdrEndPointFromGroupRTgtSource).build()
            );
        result->setSource(epdrEndPointFromGroupRTgtSource);
        return result;
    }
 
    void resolveEpdrEndPointFromGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::epdr::EndPointFromGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::epdr::EndPointFromGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464488ul, 104, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpFromGroupRTgt> > resolveInvLocalInventoryEpFromGroupRTgt(
        const std::string& invLocalInventoryEpFromGroupRTgtSource)
    {
        return modelgbp::inv::LocalInventoryEpFromGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpFromGroupRTgt").addElement(invLocalInventoryEpFromGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpFromGroupRTgt> addInvLocalInventoryEpFromGroupRTgt(
        const std::string& invLocalInventoryEpFromGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpFromGroupRTgt> result = addChild<modelgbp::inv::LocalInventoryEpFromGroupRTgt>(
            CLASS_ID, getURI(), 2152464502ul, 118,
            opflex::modb::URIBuilder(getURI()).addElement("InvLocalInventoryEpFromGroupRTgt").addElement(invLocalInventoryEpFromGroupRTgtSource).build()
            );
        result->setSource(invLocalInventoryEpFromGroupRTgtSource);
        return result;
    }
 
    void resolveInvLocalInventoryEpFromGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::LocalInventoryEpFromGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::LocalInventoryEpFromGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464502ul, 118, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::IpMappingFromGroupRTgt> > resolveInvIpMappingFromGroupRTgt(
        const std::string& invIpMappingFromGroupRTgtSource)
    {
        return modelgbp::inv::IpMappingFromGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvIpMappingFromGroupRTgt").addElement(invIpMappingFromGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::IpMappingFromGroupRTgt> addInvIpMappingFromGroupRTgt(
        const std::string& invIpMappingFromGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::inv::IpMappingFromGroupRTgt> result = addChild<modelgbp::inv::IpMappingFromGroupRTgt>(
            CLASS_ID, getURI(), 2152464510ul, 126,
            opflex::modb::URIBuilder(getURI()).addElement("InvIpMappingFromGroupRTgt").addElement(invIpMappingFromGroupRTgtSource).build()
            );
        result->setSource(invIpMappingFromGroupRTgtSource);
        return result;
    }
 
    void resolveInvIpMappingFromGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::IpMappingFromGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::IpMappingFromGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464510ul, 126, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToNetworkRSrc> > resolveGbpEpGroupToNetworkRSrc(
        )
    {
        return modelgbp::gbp::EpGroupToNetworkRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToNetworkRSrc").build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::EpGroupToNetworkRSrc> addGbpEpGroupToNetworkRSrc(
        )
    {
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToNetworkRSrc> result = addChild<modelgbp::gbp::EpGroupToNetworkRSrc>(
            CLASS_ID, getURI(), 2152464537ul, 153,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToNetworkRSrc").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToProvContractRSrc> > resolveGbpEpGroupToProvContractRSrc(
        const std::string& gbpEpGroupToProvContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToProvContractRSrcTargetClass = 143;
        return modelgbp::gbp::EpGroupToProvContractRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToProvContractRSrc").addElement(gbpEpGroupToProvContractRSrcTargetClass).addElement(gbpEpGroupToProvContractRSrcTargetName).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::EpGroupToProvContractRSrc> addGbpEpGroupToProvContractRSrc(
        const std::string& gbpEpGroupToProvContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToProvContractRSrcTargetClass = 143;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToProvContractRSrc> result = addChild<modelgbp::gbp::EpGroupToProvContractRSrc>(
            CLASS_ID, getURI(), 2152464540ul, 156,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToProvContractRSrc").addElement(gbpEpGroupToProvContractRSrcTargetClass).addElement(gbpEpGroupToProvContractRSrcTargetName).build()
            );
        result->setTargetContract(opflex::modb::URI(gbpEpGroupToProvContractRSrcTargetName));
        return result;
    }
 
    void resolveGbpEpGroupToProvContractRSrc(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbp::EpGroupToProvContractRSrc> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbp::EpGroupToProvContractRSrc>(
            getFramework(), CLASS_ID, getURI(), 2152464540ul, 156, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> > resolveGbpEpGroupToConsContractRSrc(
        const std::string& gbpEpGroupToConsContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToConsContractRSrcTargetClass = 143;
        return modelgbp::gbp::EpGroupToConsContractRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToConsContractRSrc").addElement(gbpEpGroupToConsContractRSrcTargetClass).addElement(gbpEpGroupToConsContractRSrcTargetName).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> addGbpEpGroupToConsContractRSrc(
        const std::string& gbpEpGroupToConsContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToConsContractRSrcTargetClass = 143;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> result = addChild<modelgbp::gbp::EpGroupToConsContractRSrc>(
            CLASS_ID, getURI(), 2152464543ul, 159,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToConsContractRSrc").addElement(gbpEpGroupToConsContractRSrcTargetClass).addElement(gbpEpGroupToConsContractRSrcTargetName).build()
            );
        result->setTargetContract(opflex::modb::URI(gbpEpGroupToConsContractRSrcTargetName));
        return result;
    }
 
    void resolveGbpEpGroupToConsContractRSrc(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbp::EpGroupToConsContractRSrc>(
            getFramework(), CLASS_ID, getURI(), 2152464543ul, 159, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> > resolveGbpEpGroupToIntraContractRSrc(
        const std::string& gbpEpGroupToIntraContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToIntraContractRSrcTargetClass = 143;
        return modelgbp::gbp::EpGroupToIntraContractRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToIntraContractRSrc").addElement(gbpEpGroupToIntraContractRSrcTargetClass).addElement(gbpEpGroupToIntraContractRSrcTargetName).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> addGbpEpGroupToIntraContractRSrc(
        const std::string& gbpEpGroupToIntraContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToIntraContractRSrcTargetClass = 143;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> result = addChild<modelgbp::gbp::EpGroupToIntraContractRSrc>(
            CLASS_ID, getURI(), 2152464546ul, 162,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToIntraContractRSrc").addElement(gbpEpGroupToIntraContractRSrcTargetClass).addElement(gbpEpGroupToIntraContractRSrcTargetName).build()
            );
        result->setTargetContract(opflex::modb::URI(gbpEpGroupToIntraContractRSrcTargetName));
        return result;
    }
 
    void resolveGbpEpGroupToIntraContractRSrc(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbp::EpGroupToIntraContractRSrc>(
            getFramework(), CLASS_ID, getURI(), 2152464546ul, 162, out);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToSubnetsRSrc> > resolveGbpEpGroupToSubnetsRSrc(
        )
    {
        return modelgbp::gbp::EpGroupToSubnetsRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToSubnetsRSrc").build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::EpGroupToSubnetsRSrc> addGbpEpGroupToSubnetsRSrc(
        )
    {
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToSubnetsRSrc> result = addChild<modelgbp::gbp::EpGroupToSubnetsRSrc>(
            CLASS_ID, getURI(), 2152464549ul, 165,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToSubnetsRSrc").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt> > resolveGbpL3ExternalNetworkFromNatEPGroupRTgt(
        const std::string& gbpL3ExternalNetworkFromNatEPGroupRTgtSource)
    {
        return modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpL3ExternalNetworkFromNatEPGroupRTgt").addElement(gbpL3ExternalNetworkFromNatEPGroupRTgtSource).build());
    }
 
    OF_SHARED_PTR<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt> addGbpL3ExternalNetworkFromNatEPGroupRTgt(
        const std::string& gbpL3ExternalNetworkFromNatEPGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt> result = addChild<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt>(
            CLASS_ID, getURI(), 2152464561ul, 177,
            opflex::modb::URIBuilder(getURI()).addElement("GbpL3ExternalNetworkFromNatEPGroupRTgt").addElement(gbpL3ExternalNetworkFromNatEPGroupRTgtSource).build()
            );
        result->setSource(gbpL3ExternalNetworkFromNatEPGroupRTgtSource);
        return result;
    }
 
    void resolveGbpL3ExternalNetworkFromNatEPGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbp::L3ExternalNetworkFromNatEPGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152464561ul, 177, 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& policySpaceName,
        const std::string& gbpEpGroupName)
    {
        MO::remove(framework, CLASS_ID, opflex::modb::URIBuilder().addElement("PolicyUniverse").addElement("PolicySpace").addElement(policySpaceName).addElement("GbpEpGroup").addElement(gbpEpGroupName).build());
    }
 
    static void remove(
        const std::string& policySpaceName,
        const std::string& gbpEpGroupName)
    {
        remove(opflex::ofcore::OFFramework::defaultInstance(),policySpaceName,gbpEpGroupName);
    }
 
    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);
    }
 
    EpGroup(
        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 EpGroup
 
} // namespace gbp
} // namespace modelgbp
#endif // GI_GBP_EPGROUP_HPP