nedresourcecache.h

Go to the documentation of this file.

//==========================================================================
// NEDRESOURCECACHE.H -
//
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 2002-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/


#ifndef __NEDRESOURCECACHE_H
#define __NEDRESOURCECACHE_H

#include <map>
#include <vector>
#include <string>
#include "nedelements.h"
#include "nedtypeinfo.h"

NAMESPACE_BEGIN


struct NEDLookupContext
{
    NEDElement *element;  // compound module or NED file
    std::string qname;    // fully qualified name, or (for NED files) package name
    NEDLookupContext(NEDElement *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 {return p->lookup(qname)!=NULL;}
          virtual int size() const {return p->getTypeNames().size();}
          virtual const char *get(int k) const {return p->getTypeNames()[k].c_str();}
      };

  protected:
    typedef std::map<std::string, NEDElement *> 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;
        NEDElement *node;
        PendingNedType(const char *q, bool inner, NEDElement *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 NEDElement *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(NEDElement *node, const std::string& namespacePrefix, bool areInnerTypes);
    virtual void collectNedType(const char *qname, bool isInnerType, NEDElement *node);
    virtual bool areDependenciesResolved(const char *qname, NEDElement *node);
    virtual void registerPendingNedTypes();
    virtual void registerNedType(const char *qname, bool isInnerType, NEDElement *node);

  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, NEDElement *node);  //XXX make protected?

    virtual NEDElement *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, NEDElement *node);

};

NAMESPACE_END


#endif