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:
    typedef std::map<std::string, ASTNode *> NedFileMap;
    typedef std::map<std::string, NedTypeInfo *> NedTypeInfoMap;

    // table of loaded NED files; maps file name to NED element.
    NedFileMap files;

    // table of NED type declarations; key is fully qualified name, and
    // elements point into the files map
    NedTypeInfoMap 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 registerBuiltinDeclarations();
    virtual int doLoadNedSourceFolder(const char *foldername, const char *expectedPackage);
    virtual void doLoadNedFileOrText(const char *nedfname, const char *nedtext, const char *expectedPackage, bool isXML);
    virtual ASTNode *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);

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

    virtual bool addFile(const char *fname, ASTNode *node);  //XXX make protected?

    virtual ASTNode *getFile(const char *fname) const;

    virtual NedFileElement *getParentPackageNedFile(NedFileElement *nedfile) 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