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
{
  protected:
    std::string qualifiedName;
    bool availabilityTested;
    bool available;

    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;

  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: 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: helper for checkSignal()
    cObjectFactory *lookupClass(const char *className) 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: 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:
    virtual cModule *createModuleObject() = 0;

    //TODO in 5.0, these methods should be internal (i.e. nor public API)
    virtual void addParametersAndGatesTo(cModule *mod) = 0;

    virtual void setupGateVectors(cModule *mod) = 0;

    virtual void buildInside(cModule *mod) = 0;

    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);

    virtual cModule *create(const char *name, cModule *parentmod, int vectorsize, int index);

    virtual cModule *createScheduleInit(const char *name, cModule *parentmod);

    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:
    virtual cChannel *createChannelObject() = 0;

    virtual void addParametersTo(cChannel *channel) = 0;

    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