nedresourcecache.h

Go to the documentation of this file.

//==========================================================================
// NEDRESOURCECACHE.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_NEDRESOURCECACHE_H
#define __OMNETPP_NEDXML_NEDRESOURCECACHE_H
 
#include <map>
#include <vector>
#include <string>
#include "nedelements.h"
#include "nedtypeinfo.h"
 
namespace omnetpp {
namespace nedxml {
 
class ErrorStore;
 
struct NedLookupContext
{
    ASTNode *element;  // compound module or NED file
    std::string qname;    // fully qualified name, or (for NED files) package name
    NedLookupContext(ASTNode *e, const char *q) {element=e;qname=q;}
};
 
class NEDXML_API NedResourceCache
{
  public:
      class INedTypeNames {
        public:
          virtual bool contains(const char *qname) const = 0;
 
          virtual int size() const = 0;
 
          virtual const char *get(int k) const = 0;
 
          virtual ~INedTypeNames() {}  // make the compiler happy
      };
 
      class CachedTypeNames : public INedTypeNames {
        protected:
          NedResourceCache *p;
        public:
          CachedTypeNames(NedResourceCache *p) {this->p=p;}
          virtual bool contains(const char *qname) const override {return p->lookup(qname)!=nullptr;}
          virtual int size() const override {return p->getTypeNames().size();}
          virtual const char *get(int k) const override {return p->getTypeNames()[k].c_str();}
      };
 
  protected:
    // table of loaded NED files (by NED file name as absolute path, canonical representation)
    std::map<std::string,NedFileElement*> nedFiles;
 
    // "package.ned" files by package name (only one per package accepted)
    std::map<std::string, NedFileElement*> packageDotNedFiles;
 
    // true after doneLoadingNedFiles() has been called
    bool doneLoadingNedFilesCalled = false;
 
    // table of NED type declarations; key is fully qualified name, and elements point into nedFiles
    std::map<std::string, NedTypeInfo*> nedTypes;
 
    // cached keys of the nedTypes map, for getTypeNames(); zero size means out of date
    mutable std::vector<std::string> nedTypeNames;
 
    // maps the loaded source NED folders (as absolute paths, canonical representation)
    // to package names
    typedef std::map<std::string,std::string> StringMap;
    StringMap folderPackages;
 
    struct PendingNedType {
        std::string qname;
        bool isInnerType;
        ASTNode *node;
        PendingNedType(const char *q, bool inner, ASTNode *e) {qname=q;isInnerType=inner;node=e;}
    };
 
    // storage for NED components not resolved yet because of missing dependencies
    std::vector<PendingNedType> pendingList;
 
  protected:
    virtual void addFile(const char *fname, NedFileElement *node);
    virtual void registerBuiltinDeclarations();
    virtual int doLoadNedSourceFolder(const char *foldername, const char *expectedPackage, const std::vector<std::string>& excludedFolders);
    virtual void doLoadNedFileOrText(const char *nedfname, const char *nedtext, const char *expectedPackage, bool isXML);
    virtual NedFileElement *parseAndValidateNedFileOrText(const char *nedfname, const char *nedtext, bool isXML);
    virtual std::string determineRootPackageName(const char *nedSourceFolderName);
    virtual std::string getNedSourceFolderForFolder(const char *folder) const;
    virtual void collectNedTypesFrom(ASTNode *node, const std::string& packagePrefix, bool areInnerTypes);
    virtual void collectNedType(const char *qname, bool isInnerType, ASTNode *node);
    virtual bool areDependenciesResolved(const char *qname, ASTNode *node);
    virtual void registerPendingNedTypes();
    virtual void registerNedType(const char *qname, bool isInnerType, ASTNode *node);
    virtual std::string getFirstError(ErrorStore *errors, const char *prefix=nullptr);
 
  public:
    NedResourceCache() {}
 
    virtual ~NedResourceCache();
 
    virtual int loadNedSourceFolder(const char *foldername, const char *excludedPackages);
 
    virtual void loadNedFile(const char *nedfname, const char *expectedPackage, bool isXML);
 
    virtual void loadNedText(const char *name, const char *nedtext, const char *expectedPackage, bool isXML);
 
    virtual void doneLoadingNedFiles();
 
    std::vector<NedFileElement*> getPackageNedListForLookup(const char *packageName) const;
 
    virtual NedTypeInfo *lookup(const char *qname) const;
 
    virtual NedTypeInfo *getDecl(const char *qname) const;
 
    virtual std::string resolveNedType(const NedLookupContext& context, const char *nedtypename, INedTypeNames *qnames);
 
    virtual std::string resolveNedType(const NedLookupContext& context, const char *nedtypename) {
        CachedTypeNames names(this);
        return resolveNedType(context, nedtypename, &names);
    }
 
    virtual const std::vector<std::string>& getTypeNames() const;
 
    virtual std::string getNedPackageForFolder(const char *folder) const;
 
    static NedLookupContext getParentContextOf(const char *qname, ASTNode *node);
 
};
 
}  // namespace nedxml
}  // namespace omnetpp
 
 
#endif