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(inv/RemoteInventoryEpFromGroupRTgt)
 */
#include "modelgbp/inv/RemoteInventoryEpFromGroupRTgt.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/EpGroupToTabooContractRSrc)
 */
#include "modelgbp/gbp/EpGroupToTabooContractRSrc.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 = 161;

    bool isIntraGroupPolicySet()
    {
        return getObjectInstance().isSet(5275650ul, opflex::modb::PropertyInfo::ENUM8);
    }

    boost::optional<const uint8_t> getIntraGroupPolicy()
    {
        if (isIntraGroupPolicySet())
            return (const uint8_t)getObjectInstance().getUInt64(5275650ul);
        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(5275650ul, newValue);
        return *this;
    }

    modelgbp::gbp::EpGroup& unsetIntraGroupPolicy()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(5275650ul, opflex::modb::PropertyInfo::ENUM8, opflex::modb::PropertyInfo::SCALAR);
        return *this;
    }

    bool isNameSet()
    {
        return getObjectInstance().isSet(5275649ul, opflex::modb::PropertyInfo::STRING);
    }

    boost::optional<const std::string&> getName()
    {
        if (isNameSet())
            return getObjectInstance().getString(5275649ul);
        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(5275649ul, newValue);
        return *this;
    }

    modelgbp::gbp::EpGroup& unsetName()
    {
        getTLMutator().modify(getClassId(), getURI())->unset(5275649ul, 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(), 2152759308ul, 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(), 2152759308ul, 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(), 2152759312ul, 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(), 2152759312ul, 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(), 2152759327ul, 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(), 2152759327ul, 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(), 2152759336ul, 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(), 2152759374ul, 78,
            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(), 2152759374ul, 78, 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(), 2152759403ul, 107,
            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(), 2152759403ul, 107, 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(), 2152759417ul, 121,
            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(), 2152759417ul, 121, 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(), 2152759426ul, 130,
            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(), 2152759426ul, 130, out);
    }

    boost::optional<OF_SHARED_PTR<modelgbp::inv::RemoteInventoryEpFromGroupRTgt> > resolveInvRemoteInventoryEpFromGroupRTgt(
        const std::string& invRemoteInventoryEpFromGroupRTgtSource)
    {
        return modelgbp::inv::RemoteInventoryEpFromGroupRTgt::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvRemoteInventoryEpFromGroupRTgt").addElement(invRemoteInventoryEpFromGroupRTgtSource).build());
    }

    OF_SHARED_PTR<modelgbp::inv::RemoteInventoryEpFromGroupRTgt> addInvRemoteInventoryEpFromGroupRTgt(
        const std::string& invRemoteInventoryEpFromGroupRTgtSource)
    {
        OF_SHARED_PTR<modelgbp::inv::RemoteInventoryEpFromGroupRTgt> result = addChild<modelgbp::inv::RemoteInventoryEpFromGroupRTgt>(
            CLASS_ID, getURI(), 2152759440ul, 144,
            opflex::modb::URIBuilder(getURI()).addElement("InvRemoteInventoryEpFromGroupRTgt").addElement(invRemoteInventoryEpFromGroupRTgtSource).build()
            );
        result->setSource(invRemoteInventoryEpFromGroupRTgtSource);
        return result;
    }

    void resolveInvRemoteInventoryEpFromGroupRTgt(/* out */ std::vector<OF_SHARED_PTR<modelgbp::inv::RemoteInventoryEpFromGroupRTgt> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::inv::RemoteInventoryEpFromGroupRTgt>(
            getFramework(), CLASS_ID, getURI(), 2152759440ul, 144, 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(), 2152759458ul, 162,
            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 = 152;
        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 = 152;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToProvContractRSrc> result = addChild<modelgbp::gbp::EpGroupToProvContractRSrc>(
            CLASS_ID, getURI(), 2152759461ul, 165,
            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(), 2152759461ul, 165, out);
    }

    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> > resolveGbpEpGroupToConsContractRSrc(
        const std::string& gbpEpGroupToConsContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToConsContractRSrcTargetClass = 152;
        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 = 152;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToConsContractRSrc> result = addChild<modelgbp::gbp::EpGroupToConsContractRSrc>(
            CLASS_ID, getURI(), 2152759464ul, 168,
            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(), 2152759464ul, 168, out);
    }

    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> > resolveGbpEpGroupToIntraContractRSrc(
        const std::string& gbpEpGroupToIntraContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToIntraContractRSrcTargetClass = 152;
        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 = 152;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToIntraContractRSrc> result = addChild<modelgbp::gbp::EpGroupToIntraContractRSrc>(
            CLASS_ID, getURI(), 2152759467ul, 171,
            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(), 2152759467ul, 171, out);
    }

    boost::optional<OF_SHARED_PTR<modelgbp::gbp::EpGroupToTabooContractRSrc> > resolveGbpEpGroupToTabooContractRSrc(
        const std::string& gbpEpGroupToTabooContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToTabooContractRSrcTargetClass = 152;
        return modelgbp::gbp::EpGroupToTabooContractRSrc::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToTabooContractRSrc").addElement(gbpEpGroupToTabooContractRSrcTargetClass).addElement(gbpEpGroupToTabooContractRSrcTargetName).build());
    }

    OF_SHARED_PTR<modelgbp::gbp::EpGroupToTabooContractRSrc> addGbpEpGroupToTabooContractRSrc(
        const std::string& gbpEpGroupToTabooContractRSrcTargetName)
    {
        opflex::modb::class_id_t gbpEpGroupToTabooContractRSrcTargetClass = 152;
        OF_SHARED_PTR<modelgbp::gbp::EpGroupToTabooContractRSrc> result = addChild<modelgbp::gbp::EpGroupToTabooContractRSrc>(
            CLASS_ID, getURI(), 2152759470ul, 174,
            opflex::modb::URIBuilder(getURI()).addElement("GbpEpGroupToTabooContractRSrc").addElement(gbpEpGroupToTabooContractRSrcTargetClass).addElement(gbpEpGroupToTabooContractRSrcTargetName).build()
            );
        result->setTargetContract(opflex::modb::URI(gbpEpGroupToTabooContractRSrcTargetName));
        return result;
    }

    void resolveGbpEpGroupToTabooContractRSrc(/* out */ std::vector<OF_SHARED_PTR<modelgbp::gbp::EpGroupToTabooContractRSrc> >& out)
    {
        opflex::modb::mointernal::MO::resolveChildren<modelgbp::gbp::EpGroupToTabooContractRSrc>(
            getFramework(), CLASS_ID, getURI(), 2152759470ul, 174, 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(), 2152759473ul, 177,
            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(), 2152759485ul, 189,
            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(), 2152759485ul, 189, 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