Root.hpp

 
#pragma once
#ifndef GI_DMTREE_ROOT_HPP
#define GI_DMTREE_ROOT_HPP
 
#include <boost/optional.hpp>
#include "opflex/modb/URIBuilder.h"
#include "opflex/modb/mo-internal/MO.h"
/*
 * contains: item:mclass(relator/Universe)
 */
#include "modelgbp/relator/Universe.hpp"
/*
 * contains: item:mclass(gbpe/VMUniverse)
 */
#include "modelgbp/gbpe/VMUniverse.hpp"
/*
 * contains: item:mclass(gbpe/TunnelEpUniverse)
 */
#include "modelgbp/gbpe/TunnelEpUniverse.hpp"
/*
 * contains: item:mclass(domain/Config)
 */
#include "modelgbp/domain/Config.hpp"
/*
 * contains: item:mclass(dci/Universe)
 */
#include "modelgbp/dci/Universe.hpp"
/*
 * contains: item:mclass(dci/Discoverer)
 */
#include "modelgbp/dci/Discoverer.hpp"
/*
 * contains: item:mclass(epdr/L2Discovered)
 */
#include "modelgbp/epdr/L2Discovered.hpp"
/*
 * contains: item:mclass(epdr/L3Discovered)
 */
#include "modelgbp/epdr/L3Discovered.hpp"
/*
 * contains: item:mclass(inv/Universe)
 */
#include "modelgbp/inv/Universe.hpp"
/*
 * contains: item:mclass(epr/L2Universe)
 */
#include "modelgbp/epr/L2Universe.hpp"
/*
 * contains: item:mclass(epr/L3Universe)
 */
#include "modelgbp/epr/L3Universe.hpp"
/*
 * contains: item:mclass(observer/EpStatUniverse)
 */
#include "modelgbp/observer/EpStatUniverse.hpp"
/*
 * contains: item:mclass(observer/PolicyStatUniverse)
 */
#include "modelgbp/observer/PolicyStatUniverse.hpp"
/*
 * contains: item:mclass(policy/Universe)
 */
#include "modelgbp/policy/Universe.hpp"
 
namespace modelgbp {
namespace dmtree {
 
class Root
    : public opflex::modb::mointernal::MO
{
public:
 
    static const opflex::modb::class_id_t CLASS_ID = 1;
 
    static OF_SHARED_PTR<modelgbp::dmtree::Root> createRootElement(opflex::ofcore::OFFramework& framework)
    {
        return opflex::modb::mointernal::MO::createRootElement<modelgbp::dmtree::Root>(framework, CLASS_ID);
    }
 
    static OF_SHARED_PTR<modelgbp::dmtree::Root> createRootElement()
    {
        return createRootElement(opflex::ofcore::OFFramework::defaultInstance());;
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::dmtree::Root> > resolve(
        opflex::ofcore::OFFramework& framework,
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::dmtree::Root>(framework, CLASS_ID, uri);
    }
 
    static boost::optional<OF_SHARED_PTR<modelgbp::dmtree::Root> > resolve(
        const opflex::modb::URI& uri)
    {
        return opflex::modb::mointernal::MO::resolve<modelgbp::dmtree::Root>(opflex::ofcore::OFFramework::defaultInstance(), CLASS_ID, uri);
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::relator::Universe> > resolveRelatorUniverse(
        )
    {
        return modelgbp::relator::Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("RelatorUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::relator::Universe> addRelatorUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::relator::Universe> result = addChild<modelgbp::relator::Universe>(
            CLASS_ID, getURI(), 2147516423ul, 7,
            opflex::modb::URIBuilder(getURI()).addElement("RelatorUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::VMUniverse> > resolveGbpeVMUniverse(
        )
    {
        return modelgbp::gbpe::VMUniverse::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeVMUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::VMUniverse> addGbpeVMUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::gbpe::VMUniverse> result = addChild<modelgbp::gbpe::VMUniverse>(
            CLASS_ID, getURI(), 2147516450ul, 34,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeVMUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::gbpe::TunnelEpUniverse> > resolveGbpeTunnelEpUniverse(
        )
    {
        return modelgbp::gbpe::TunnelEpUniverse::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("GbpeTunnelEpUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::gbpe::TunnelEpUniverse> addGbpeTunnelEpUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::gbpe::TunnelEpUniverse> result = addChild<modelgbp::gbpe::TunnelEpUniverse>(
            CLASS_ID, getURI(), 2147516460ul, 44,
            opflex::modb::URIBuilder(getURI()).addElement("GbpeTunnelEpUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::domain::Config> > resolveDomainConfig(
        )
    {
        return modelgbp::domain::Config::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("DomainConfig").build());
    }
 
    OF_SHARED_PTR<modelgbp::domain::Config> addDomainConfig(
        )
    {
        OF_SHARED_PTR<modelgbp::domain::Config> result = addChild<modelgbp::domain::Config>(
            CLASS_ID, getURI(), 2147516472ul, 56,
            opflex::modb::URIBuilder(getURI()).addElement("DomainConfig").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::dci::Universe> > resolveDciUniverse(
        )
    {
        return modelgbp::dci::Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("DciUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::dci::Universe> addDciUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::dci::Universe> result = addChild<modelgbp::dci::Universe>(
            CLASS_ID, getURI(), 2147516497ul, 81,
            opflex::modb::URIBuilder(getURI()).addElement("DciUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::dci::Discoverer> > resolveDciDiscoverer(
        )
    {
        return modelgbp::dci::Discoverer::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("DciDiscoverer").build());
    }
 
    OF_SHARED_PTR<modelgbp::dci::Discoverer> addDciDiscoverer(
        )
    {
        OF_SHARED_PTR<modelgbp::dci::Discoverer> result = addChild<modelgbp::dci::Discoverer>(
            CLASS_ID, getURI(), 2147516498ul, 82,
            opflex::modb::URIBuilder(getURI()).addElement("DciDiscoverer").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::epdr::L2Discovered> > resolveEpdrL2Discovered(
        )
    {
        return modelgbp::epdr::L2Discovered::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("EpdrL2Discovered").build());
    }
 
    OF_SHARED_PTR<modelgbp::epdr::L2Discovered> addEpdrL2Discovered(
        )
    {
        OF_SHARED_PTR<modelgbp::epdr::L2Discovered> result = addChild<modelgbp::epdr::L2Discovered>(
            CLASS_ID, getURI(), 2147516527ul, 111,
            opflex::modb::URIBuilder(getURI()).addElement("EpdrL2Discovered").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::epdr::L3Discovered> > resolveEpdrL3Discovered(
        )
    {
        return modelgbp::epdr::L3Discovered::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("EpdrL3Discovered").build());
    }
 
    OF_SHARED_PTR<modelgbp::epdr::L3Discovered> addEpdrL3Discovered(
        )
    {
        OF_SHARED_PTR<modelgbp::epdr::L3Discovered> result = addChild<modelgbp::epdr::L3Discovered>(
            CLASS_ID, getURI(), 2147516528ul, 112,
            opflex::modb::URIBuilder(getURI()).addElement("EpdrL3Discovered").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::inv::Universe> > resolveInvUniverse(
        )
    {
        return modelgbp::inv::Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("InvUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::inv::Universe> addInvUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::inv::Universe> result = addChild<modelgbp::inv::Universe>(
            CLASS_ID, getURI(), 2147516529ul, 113,
            opflex::modb::URIBuilder(getURI()).addElement("InvUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::epr::L2Universe> > resolveEprL2Universe(
        )
    {
        return modelgbp::epr::L2Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("EprL2Universe").build());
    }
 
    OF_SHARED_PTR<modelgbp::epr::L2Universe> addEprL2Universe(
        )
    {
        OF_SHARED_PTR<modelgbp::epr::L2Universe> result = addChild<modelgbp::epr::L2Universe>(
            CLASS_ID, getURI(), 2147516554ul, 138,
            opflex::modb::URIBuilder(getURI()).addElement("EprL2Universe").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::epr::L3Universe> > resolveEprL3Universe(
        )
    {
        return modelgbp::epr::L3Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("EprL3Universe").build());
    }
 
    OF_SHARED_PTR<modelgbp::epr::L3Universe> addEprL3Universe(
        )
    {
        OF_SHARED_PTR<modelgbp::epr::L3Universe> result = addChild<modelgbp::epr::L3Universe>(
            CLASS_ID, getURI(), 2147516555ul, 139,
            opflex::modb::URIBuilder(getURI()).addElement("EprL3Universe").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::observer::EpStatUniverse> > resolveObserverEpStatUniverse(
        )
    {
        return modelgbp::observer::EpStatUniverse::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("ObserverEpStatUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::observer::EpStatUniverse> addObserverEpStatUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::observer::EpStatUniverse> result = addChild<modelgbp::observer::EpStatUniverse>(
            CLASS_ID, getURI(), 2147516628ul, 212,
            opflex::modb::URIBuilder(getURI()).addElement("ObserverEpStatUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::observer::PolicyStatUniverse> > resolveObserverPolicyStatUniverse(
        )
    {
        return modelgbp::observer::PolicyStatUniverse::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("ObserverPolicyStatUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::observer::PolicyStatUniverse> addObserverPolicyStatUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::observer::PolicyStatUniverse> result = addChild<modelgbp::observer::PolicyStatUniverse>(
            CLASS_ID, getURI(), 2147516629ul, 213,
            opflex::modb::URIBuilder(getURI()).addElement("ObserverPolicyStatUniverse").build()
            );
        return result;
    }
 
    boost::optional<OF_SHARED_PTR<modelgbp::policy::Universe> > resolvePolicyUniverse(
        )
    {
        return modelgbp::policy::Universe::resolve(getFramework(), opflex::modb::URIBuilder(getURI()).addElement("PolicyUniverse").build());
    }
 
    OF_SHARED_PTR<modelgbp::policy::Universe> addPolicyUniverse(
        )
    {
        OF_SHARED_PTR<modelgbp::policy::Universe> result = addChild<modelgbp::policy::Universe>(
            CLASS_ID, getURI(), 2147516639ul, 223,
            opflex::modb::URIBuilder(getURI()).addElement("PolicyUniverse").build()
            );
        return result;
    }
 
    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 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);
    }
 
    Root(
        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 Root
 
} // namespace dmtree
} // namespace modelgbp
#endif // GI_DMTREE_ROOT_HPP