nedtypeinfo.h

Go to the documentation of this file.

//==========================================================================
// NEDTYPEINFO.H -
//
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 2002-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_NEDXML_NEDTYPEINFO_H
#define __OMNETPP_NEDXML_NEDTYPEINFO_H
 
#include <map>
#include <vector>
#include <string>
#include <optional>
#include "common/commonutil.h"
#include "nedelements.h"
 
namespace omnetpp {
namespace nedxml {
 
class NedResourceCache;
 
class NEDXML_API NedTypeInfo
{
  public:
    enum Type {SIMPLE_MODULE, COMPOUND_MODULE, MODULEINTERFACE, CHANNEL, CHANNELINTERFACE};
 
  protected:
    // the resolver this type is in
    NedResourceCache *resolver;
 
    Type type;
    std::string qualifiedName;
    bool isInner;  // whether it is an inner type
    ASTNode *tree; // points into resolver
 
    bool resolved = false;
    bool resolving = false;
 
    // Important: The fields below are only filled in when the "resolved" flag is true.
 
    typedef std::vector<std::string> StringVector;
    typedef std::map<std::string,ASTNode*> NameToElementMap;
 
    // inheritance. Vectors contain fully qualifies names, and include
    // indirect base types/interfaces as well (transitive closure).
    StringVector extendsNames;
    StringVector interfaceNames;
 
    std::string enclosingTypeName;
 
    // simple module/channel C++ class to instantiate
    std::string implClassName;
    // cached return value of getDocumentation
    mutable std::optional<std::string> documentation;
 
    // local declarations by name
    NameToElementMap localInnerTypeDecls;
    NameToElementMap localParamDecls;
    NameToElementMap localGateDecls;
    NameToElementMap localSubmoduleDecls;
    NameToElementMap localConnectionDecls;
    NameToElementMap allLocalDecls;
 
  protected:
    void checkComplianceToInterface(NedTypeInfo *interfaceDecl);
    void collectLocalDeclarations();
    void addToElementMap(NameToElementMap& elementMap, ASTNode *node);
    void mergeElementMap(NameToElementMap& destMap, const NameToElementMap& elementMap);
    void resolveIfNeeded() const {if (!isResolved()) const_cast<NedTypeInfo*>(this)->resolve(); /*ouch*/}
 
  public:
    NedTypeInfo(NedResourceCache *resolver, const char *qname, bool isInnerType, ASTNode *tree);
 
    virtual ~NedTypeInfo();
 
    virtual const char *getName() const;
 
    virtual const char *getFullName() const;
 
    virtual ASTNode *getTree() const;
 
    NedResourceCache *getResolver() const  {return resolver;}
 
    virtual Type getType() const {return type;}
 
    virtual bool isNetwork() const;
 
    virtual const char *getSourceFileName() const;
 
    virtual std::string getPackage() const;
 
    virtual bool isInnerType() const  {return isInner;}
 
    virtual const char *getEnclosingTypeName() const;
 
    virtual std::string str() const;
 
    virtual std::string getNedSource() const;
 
    virtual std::string getDocumentation() const;
 
    virtual bool isResolved() const {return resolved;}
 
    virtual void resolve();
 
    virtual int numExtendsNames() const  {resolveIfNeeded(); return extendsNames.size();}
 
    virtual const char *getExtendsName(int k) const;
 
    virtual int numInterfaceNames() const  {resolveIfNeeded(); return interfaceNames.size();}
 
    virtual const char *getInterfaceName(int k) const;
 
    virtual bool supportsInterface(const char *qname);
 
    virtual const char *getImplementationClassName() const;
 
    virtual std::string getPackageProperty(const char *name) const;
 
    virtual std::string getCxxNamespace() const;
 
    virtual NedTypeInfo *getSuperDecl() const;
 
    TypesElement *getTypesElement() const;
    ParametersElement *getParametersElement() const;
    GatesElement *getGatesElement() const;
    SubmodulesElement *getSubmodulesElement() const;
    ConnectionsElement *getConnectionsElement() const;
 
    SubmoduleElement *getLocalSubmoduleElement(const char *submoduleName) const;
 
    ConnectionElement *getLocalConnectionElement(long id) const;
 
    SubmoduleElement *getSubmoduleElement(const char *submoduleName) const;
 
    ConnectionElement *getConnectionElement(long id) const;
 
    ParamElement *findLocalParamDecl(const char *name) const;
 
    ParamElement *findParamDecl(const char *name) const;
 
    GateElement *findLocalGateDecl(const char *name) const;
 
    GateElement *findGateDecl(const char *name) const;
};
 
}  // namespace nedxml
}  // namespace omnetpp
 
 
#endif