ccomponenttype.h

//==========================================================================
//  CCOMPONENTTYPE.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CCOMPONENTTYPE_H
#define __OMNETPP_CCOMPONENTTYPE_H
 
#include <string>
#include <map>
#include <set>
#include "cpar.h"
#include "cgate.h"
#include "cownedobject.h"
#include "clistener.h"
 
 
namespace omnetpp {
 
class cModule;
class cChannel;
class cProperty;
class cProperties;
class cIdealChannel;
class cDelayChannel;
class cDatarateChannel;
class cObjectFactory;
 
 
class SIM_API cComponentType : public cNoncopyableOwnedObject
{
    friend class cSimulation; // clearSharedParImpls()
  protected:
    std::string qualifiedName;
    bool availabilityTested = false;
    bool available = false;
 
    typedef internal::cParImpl cParImpl;
    typedef std::map<std::string, cParImpl *> StringToParMap;
    StringToParMap sharedParMap;
 
    struct Less {bool operator()(cParImpl *a, cParImpl *b) const;};
    typedef std::set<cParImpl *, Less> ParImplSet;
    ParImplSet sharedParSet;
 
    struct SignalDesc { SimsignalType type; cObjectFactory *objectType; bool isNullable; };
    std::map<simsignal_t,SignalDesc> signalsSeen;
 
    mutable bool sourceFileDirectoryCached = false;
    mutable std::string sourceFileDirectory;
 
  protected:
    friend class cComponent;
    friend class cModule;
    friend class cChannel;
    friend class cPar;
    friend class cGate;
 
    // internal: returns the properties for this component.
    virtual cProperties *getProperties() const = 0;
 
    // internal: returns the properties of parameter
    virtual cProperties *getParamProperties(const char *paramName) const = 0;
 
    // internal: returns the properties of gate
    virtual cProperties *getGateProperties(const char *gateName) const = 0;
 
    // internal: returns the properties of a submodule.
    // (Subcomponent type is needed because with the NED "like" syntax,
    // we need the runtime type not the NED type of the submodule.)
    virtual cProperties *getSubmoduleProperties(const char *submoduleName, const char *submoduleType) const = 0;
 
    // internal: returns the properties of a contained connection.
    // (Subcomponent type is needed because with the NED "like" syntax,
    // we need the runtime type not the NED type of the submodule.)
    virtual cProperties *getConnectionProperties(int connectionId, const char *channelType) const = 0;
 
    // internal: returns the name of the C++ class that implements this NED type
    virtual const char *getImplementationClassName() const = 0;
 
    // internal: returns the default C++ namespace for the given NED type (for NED it's the @namespace package property)
    virtual std::string getCxxNamespaceForType(const char *type) const = 0;
 
    // internal: apply pattern-based ("deep") parameter settings in NED
    virtual void applyPatternAssignments(cComponent *component) = 0;
 
    // internal: sharedParMap access
    cParImpl *getSharedParImpl(const char *key) const;
    void putSharedParImpl(const char *key, cParImpl *value);
 
    // internal: sharedParSet access
    cParImpl *getSharedParImpl(cParImpl *p) const;
    void putSharedParImpl(cParImpl *p);
 
    // internal:
    virtual void clearSharedParImpls();
 
    // internal: helper for checkSignal()
    cObjectFactory *lookupClass(const char *className, const char *sourceType) const;
 
  public:
    // internal: delegates to the similar NedTypeInfo method
    virtual std::string getPackageProperty(const char *name) const {return "";}
 
    // internal: checks whether this type is available; currently tests the existence of the implementation class
    virtual bool isAvailable();
 
    // internal: delegates to the similar NedTypeInfo method
    virtual bool isInnerType() const {return false;}
 
    // internal: return the default C++ namespace at this NED type (for NED it's the @namespace package property)
    virtual std::string getCxxNamespace() const {return "";}
 
    // internal: return the path of the source file this declaration has been loaded from, or nullptr if not available
    virtual const char *getSourceFileName() const {return nullptr;}
 
    // internal: return the directory of the source file this declaration has been loaded from, or nullptr if not available
    virtual const char *getSourceFileDirectory() const;
 
    // internal: used by cComponent::emit() methods to validate signals
    virtual void checkSignal(simsignal_t signalID, SimsignalType type, cObject *obj = nullptr);
 
    // internal: returns the @signal property for the given signal, or nullptr if not found
    virtual cProperty *getSignalDeclaration(const char *signalName);
 
  public:
    cComponentType(const char *qname=nullptr);
 
    virtual ~cComponentType();
 
    virtual const char *getFullName() const override  {return qualifiedName.c_str();}
 
    virtual std::string getNedSource() const = 0;
 
    static cComponentType *find(const char *qname);
 
    static cComponentType *get(const char *qname);
};
 
 
class SIM_API cModuleType : public cComponentType
{
    friend class cModule;
  protected:
    // internal: create the module object
    virtual cModule *createModuleObject() = 0;
 
    // internal: add parameters and gates to a newly created module object.
    // Gate vectors will be created with zero size, and a further call to
    // setupGateVectors() will be needed once parameter values have been finalized/
    virtual void addParametersAndGatesTo(cModule *mod) = 0;
 
    // internal: set gate vector sizes on the module. This must be called AFTER all
    // parameters have been set (see finalizeParameters()) because gate vector sizes
    // may depend on parameter values; and it it must be invoked before connecting
    // the gates and calling mod->buildInside().
    virtual void setupGateVectors(cModule *mod) = 0;
 
    // internal: create and connect submodules of a newly created module object.
    // addParametersAndGatesTo() and setupGateVectors() must have been already called at this point.
    virtual void buildInside(cModule *mod) = 0;
 
    // internal: utility function: instantiates the given class, and tries to cast
    // the result to cModule. Raises an error if class was not found or could not be cast.
    cModule *instantiateModuleClass(const char *classname);
 
  public:
    cModuleType(const char *qname=nullptr);
 
    virtual bool isNetwork() const = 0;
 
    virtual bool isSimple() const = 0;
 
 
    virtual cModule *create(const char *name, cModule *parentmod, int index=-1);
 
    virtual cModule *createScheduleInit(const char *name, cModule *parentmod, int index=-1);
 
    static cModuleType *find(const char *qname);
 
    static cModuleType *get(const char *qname);
};
 
 
class SIM_API cChannelType : public cComponentType
{
  protected:
    static cChannelType *idealChannelType;
    static cChannelType *delayChannelType;
    static cChannelType *datarateChannelType;
 
  protected:
    // internal: create the channel object
    virtual cChannel *createChannelObject() = 0;
 
    // internal: add parameters to a newly created channel object.
    virtual void addParametersTo(cChannel *channel) = 0;
 
    // internal: utility function: instantiates the given class, and tries to cast the
    // result to cChannel. Raises an error if class was not found or could not be cast.
    cChannel *instantiateChannelClass(const char *classname);
 
  public:
 
    cChannelType(const char *qname=nullptr);
 
    virtual cChannel *create(const char *name);
 
    static cChannelType *find(const char *qname);
 
    static cChannelType *get(const char *qname);
 
    static cChannelType *getIdealChannelType();
 
    static cChannelType *getDelayChannelType();
 
    static cChannelType *getDatarateChannelType();
 
    static cIdealChannel *createIdealChannel(const char *name);
 
    static cDelayChannel *createDelayChannel(const char *name);
 
    static cDatarateChannel *createDatarateChannel(const char *name);
};
 
}  // namespace omnetpp
 
 
#endif