C++ ModuleMap类代码示例

	void MainMenuWindow::fillModules()
	{
		MenuBase* modulesMenu = getMenu("MainMenu/Modules/Menu");

		ModuleMap modules = CoreSubsystem::getSingleton().getAllModules();
		mActiveModule = CoreSubsystem::getSingleton().getActiveAdventureModule();

		for(ModuleMap::iterator modIt = modules.begin();
			modIt != modules.end(); modIt++)
		{
			ContentModule* mod = (*modIt).second;

			if (!mod->isCommon())
			{
				if (mActiveModule == NULL)
					mActiveModule = mod;

				MenuItem* it = static_cast<MenuItem*>(
					CEGUI::WindowManager::getSingleton().createWindow("RastullahLook/MenuItem",
					getNamePrefix()+"MainMenu/Modules/" + mod->getId()));

				if (mod == mActiveModule)
					it->setText(mod->getName() + " *");
				else
					it->setText(mod->getName());
				modulesMenu->addItem(it);

				it->subscribeEvent(
					MenuItem::EventClicked,
					boost::bind(&MainMenuWindow::handleChooseModule, this, it, mod));
			}
		}
	}

 void operator()(GlobalStatic<T>& globalStatic) const
 {
   ModuleMap* moduleMap = globalStatic.pointer;
   for (ModuleMap::const_iterator i = moduleMap->begin();
        i != moduleMap->end(); ++i)
   {
     delete i->second;
   }
   DefaultGlobalStaticDeleter<T> defaultDeleter;
   defaultDeleter(globalStatic);
 }

void ModuleRegistry::Register(ModuleInfo* info)
{
  static long regCount = 0;
  if (info->id > 0)
  {
    // The module was already registered
    Module* module = 0;
    {
      MutexLocker lock(*modulesLock());
      module = modules()->operator[](info->id);
      assert(module != 0);
    }
    module->Start();
  }
  else
  {
    Module* module = 0;
    // check if the module is reloaded
    {
      MutexLocker lock(*modulesLock());
      ModuleMap* map = modules();
      for (ModuleMap::const_iterator i = map->begin();
           i != map->end(); ++i)
      {
        if (i->second->GetLocation() == info->location)
        {
          module = i->second;
          info->id = module->GetModuleId();
        }
      }
    }

    if (!module)
    {
      module = new Module();
      countLock()->Lock();
      info->id = ++regCount;
      countLock()->Unlock();

      module->Init(coreModuleContext(), info);

      MutexLocker lock(*modulesLock());
      ModuleMap* map = modules();
      map->insert(std::make_pair(info->id, module));
    }
    else
    {
      module->Init(coreModuleContext(), info);
    }

    module->Start();
  }
}

std::vector<Module*> ModuleRegistry::GetModules()
{
  MutexLock lock(*modulesLock());

  std::vector<Module*> result;
  ModuleMap* map = modules();
  ModuleMap::const_iterator iter = map->begin();
  ModuleMap::const_iterator iterEnd = map->end();
  for (; iter != iterEnd; ++iter)
  {
    result.push_back(iter->second);
  }
  return result;
}

void 
VlgModule::cstTree(VlpHierTreeNode* const parent, const ModuleMap& moduleMap) const
{
   VlpInstance* inst = NULL;
   BaseModule* mn = NULL;
   VlpHierTreeNode* newNode = NULL;

   for (unsigned i = 0; i < getInstSize(); ++i) {
      inst = _instanceAry[i];
      unsigned instID = inst->getModuleID();
      if (moduleMap.getData(instID, mn) == false) {
         Msg(MSG_ERR) << "Error : The sub-module \"" << BaseModule :: getName(instID) 
              << "\" is not defined in the module \"" 
              << parent->getModule()->getModuleName() << "\"" << endl;
         exit(0);
      }
      newNode = inst->genHierTN(mn);
      parent->setChild(newNode);

      //============Handle pos mapping parameter overload===========//
      if (inst->getPOLSize() > 0) {//pos mapping
         assert (mn->isLibrary() == false);
         //pre-consider the parent module paramter overload ==> i.e. parameter propagation
         (static_cast<VlgModule*>(mn))
         ->setPOLMap(inst->getName(), inst->genPOLAry(static_cast<VlgModule*>(mn), parent));
      }
      //============================================================//
      if (!(mn->isBlackBox() || mn->isLibrary()))
         (static_cast<VlgModule*>(mn))->cstTree(newNode, moduleMap);
   }
}

/// \brief Collect the set of header includes needed to construct the given
/// module and update the TopHeaders file set of the module.
///
/// \param Module The module we're collecting includes from.
///
/// \param Includes Will be augmented with the set of \#includes or \#imports
/// needed to load all of the named headers.
static void collectModuleHeaderIncludes(const LangOptions &LangOpts,
                                        FileManager &FileMgr,
                                        ModuleMap &ModMap,
                                        clang::Module *Module,
                                        SmallVectorImpl<char> &Includes) {
    // Don't collect any headers for unavailable modules.
    if (!Module->isAvailable())
        return;

    // Add includes for each of these headers.
    for (unsigned I = 0, N = Module->NormalHeaders.size(); I != N; ++I) {
        const FileEntry *Header = Module->NormalHeaders[I];
        Module->addTopHeader(Header);
        addHeaderInclude(Header, Includes, LangOpts);
    }
    // Note that Module->PrivateHeaders will not be a TopHeader.

    if (const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader()) {
        Module->addTopHeader(UmbrellaHeader);
        if (Module->Parent) {
            // Include the umbrella header for submodules.
            addHeaderInclude(UmbrellaHeader, Includes, LangOpts);
        }
    } else if (const DirectoryEntry *UmbrellaDir = Module->getUmbrellaDir()) {
        // Add all of the headers we find in this subdirectory.
        llvm::error_code EC;
        SmallString<128> DirNative;
        llvm::sys::path::native(UmbrellaDir->getName(), DirNative);
        for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative.str(), EC),
                DirEnd;
                Dir != DirEnd && !EC; Dir.increment(EC)) {
            // Check whether this entry has an extension typically associated with
            // headers.
            if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
                    .Cases(".h", ".H", ".hh", ".hpp", true)
                    .Default(false))
                continue;

            // If this header is marked 'unavailable' in this module, don't include
            // it.
            if (const FileEntry *Header = FileMgr.getFile(Dir->path())) {
                if (ModMap.isHeaderInUnavailableModule(Header))
                    continue;
                Module->addTopHeader(Header);
            }

            // Include this header umbrella header for submodules.
            addHeaderInclude(Dir->path(), Includes, LangOpts);
        }
    }

    // Recurse into submodules.
    for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
            SubEnd = Module->submodule_end();
            Sub != SubEnd; ++Sub)
        collectModuleHeaderIncludes(LangOpts, FileMgr, ModMap, *Sub, Includes);
}

void load_imported_modules(ModuleMap &modmap, const set< string > &modnames)
{
	set< string >::const_iterator it(modnames.begin());
	map< string, Module * > modules;
	for (; it!=modnames.end(); ++it) {
		if (modmap.find(*it) != modmap.end()) {
			continue;
		}
		Module *mod = read_module(*it);
		if (!mod) {
			compile_module(modmap, *it);
			mod = read_module(*it);
			if (!mod) {
				cerr << "could not load module: "<< (*it) & DIE;
			}
			modmap[*it] = mod;
		}
	}
}

int moduleReportList(Report_TYPE type, const Proc_LIST &processList, const wchar_t *TitleIn)
{
    int				iReturnCode=DIAGLIB_OK;
    std::wstring	Title;
    ModuleMap		modules;

    if(TitleIn!=NULL)
        Title=TitleIn;
    else
        Title=L"Module list";

    reportPrintHeader2(type, Title.c_str(), REPORT_PROCESS_SEPARATOR);

    progressInit(processList.size());

    Proc_INFO info;
    Proc_LIST::const_iterator itr;
    for(itr=processList.begin(); itr!=processList.end(); itr++)
    {
        if(DIAGLIB_OK == processGetInfo(*itr,&info))
        {
            for(ModuleSet::const_iterator i=info.modulesLoaded.begin(); i!=info.modulesLoaded.end(); i++)
                modules[*i].insert(info.Name);
        }
        progressIncrement();
    }

    for(ModuleMap::const_iterator i=modules.begin(); i!=modules.end(); i++)
    {
        moduleReportInfo(type,i->first,i->second);
        moduleContributeInfo(i->first,i->second);
    }

    progressRelease();

    return iReturnCode;
}

//=======The function handle name mapping parameter overload=========//
void 
VlgModule::NamePOL_Module(const ModuleMap& moduleMap) const
{
   if (_paramNOLMap.getSize() > 0) { //parameter overload (name mapping)
      vector<string> instNameAry;
      vector<POLAry> NPA_vector; //OL Param Array
      _paramNOLMap.dfs_key(instNameAry);
      _paramNOLMap.dfs_data(NPA_vector);
      VlpInstance* instance;
      BaseModule* mn;

      for (unsigned i = 0; i < instNameAry.size(); ++i) {
         instance = getInst(instNameAry[i]);
         if (instance == NULL) {
            Msg(MSG_ERR) << "Error : Instance \"" << instNameAry[i] << "\" doesn't exist in " 
                 << getFileName() << endl;
            exit(0);
         }
         moduleMap.getData(instance->getModuleID(), mn);
         assert (mn->isLibrary() == false);
         (static_cast<VlgModule*>(mn))->setPOLMap( instance->getName(), &(NPA_vector[i]) );
      }
   }
}

/// \brief Collect the set of header includes needed to construct the given 
/// module and update the TopHeaders file set of the module.
///
/// \param Module The module we're collecting includes from.
///
/// \param Includes Will be augmented with the set of \#includes or \#imports
/// needed to load all of the named headers.
static std::error_code
collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr,
                            ModuleMap &ModMap, clang::Module *Module,
                            SmallVectorImpl<char> &Includes) {
  // Don't collect any headers for unavailable modules.
  if (!Module->isAvailable())
    return std::error_code();

  // Add includes for each of these headers.
  for (Module::Header &H : Module->Headers[Module::HK_Normal]) {
    Module->addTopHeader(H.Entry);
    // Use the path as specified in the module map file. We'll look for this
    // file relative to the module build directory (the directory containing
    // the module map file) so this will find the same file that we found
    // while parsing the module map.
    if (std::error_code Err = addHeaderInclude(H.NameAsWritten, Includes,
                                               LangOpts, Module->IsExternC))
      return Err;
  }
  // Note that Module->PrivateHeaders will not be a TopHeader.

  if (const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader()) {
    // FIXME: Track the name as written here.
    Module->addTopHeader(UmbrellaHeader);
    if (Module->Parent) {
      // Include the umbrella header for submodules.
      if (std::error_code Err = addHeaderInclude(UmbrellaHeader, Includes,
                                                 LangOpts, Module->IsExternC))
        return Err;
    }
  } else if (const DirectoryEntry *UmbrellaDir = Module->getUmbrellaDir()) {
    // Add all of the headers we find in this subdirectory.
    std::error_code EC;
    SmallString<128> DirNative;
    llvm::sys::path::native(UmbrellaDir->getName(), DirNative);
    for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative, EC), 
                                                     DirEnd;
         Dir != DirEnd && !EC; Dir.increment(EC)) {
      // Check whether this entry has an extension typically associated with 
      // headers.
      if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
          .Cases(".h", ".H", ".hh", ".hpp", true)
          .Default(false))
        continue;

      const FileEntry *Header = FileMgr.getFile(Dir->path());
      // FIXME: This shouldn't happen unless there is a file system race. Is
      // that worth diagnosing?
      if (!Header)
        continue;

      // If this header is marked 'unavailable' in this module, don't include 
      // it.
      if (ModMap.isHeaderUnavailableInModule(Header, Module))
        continue;

      // Include this header as part of the umbrella directory.
      // FIXME: Track the name as written through to here.
      Module->addTopHeader(Header);
      if (std::error_code Err =
              addHeaderInclude(Header, Includes, LangOpts, Module->IsExternC))
        return Err;
    }

    if (EC)
      return EC;
  }

  // Recurse into submodules.
  for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
                                      SubEnd = Module->submodule_end();
       Sub != SubEnd; ++Sub)
    if (std::error_code Err = collectModuleHeaderIncludes(
            LangOpts, FileMgr, ModMap, *Sub, Includes))
      return Err;

  return std::error_code();
}

bool checkModule(string const & name, bool command)
{
	// Cache to avoid slowdown by repated searches
	static set<string> failed[2];

	// Only add the module if the command was actually defined in the LyX preamble
	if (command) {
		if (possible_textclass_commands.find('\\' + name) == possible_textclass_commands.end())
			return false;
	} else {
		if (possible_textclass_environments.find(name) == possible_textclass_environments.end())
			return false;
	}
	if (failed[command].find(name) != failed[command].end())
		return false;

	// Create list of dummy document classes if not already done.
	// This is needed since a module cannot be read on its own, only as
	// part of a document class.
	LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()];
	typedef map<string, DocumentClass *> ModuleMap;
	static ModuleMap modules;
	static bool init = true;
	if (init) {
		baseClass.load();
		DocumentClassBundle & bundle = DocumentClassBundle::get();
		LyXModuleList::const_iterator const end = theModuleList.end();
		LyXModuleList::const_iterator it = theModuleList.begin();
		for (; it != end; it++) {
			string const module = it->getID();
			LayoutModuleList m;
			// FIXME this excludes all modules that depend on another one
			if (!m.moduleCanBeAdded(module, &baseClass))
				continue;
			m.push_back(module);
			modules[module] = &bundle.makeDocumentClass(baseClass, m);
		}
		init = false;
	}

	// Try to find a module that defines the command.
	// Only add it if the definition can be found in the preamble of the
	// style that corresponds to the command. This is a heuristic and
	// different from the way how we parse the builtin commands of the
	// text class (in that case we only compare the name), but it is
	// needed since it is not unlikely that two different modules define a
	// command with the same name.
	ModuleMap::iterator const end = modules.end();
	for (ModuleMap::iterator it = modules.begin(); it != end; it++) {
		string const module = it->first;
		if (!used_modules.moduleCanBeAdded(module, &baseClass))
			continue;
		if (findLayoutWithoutModule(textclass, name, command))
			continue;
		if (findInsetLayoutWithoutModule(textclass, name, command))
			continue;
		DocumentClass const * c = it->second;
		Layout const * layout = findLayoutWithoutModule(*c, name, command);
		InsetLayout const * insetlayout = layout ? 0 :
			findInsetLayoutWithoutModule(*c, name, command);
		docstring preamble;
		if (layout)
			preamble = layout->preamble();
		else if (insetlayout)
			preamble = insetlayout->preamble();
		if (preamble.empty())
			continue;
		bool add = false;
		if (command) {
			FullCommand const & cmd =
				possible_textclass_commands['\\' + name];
			if (preamble.find(cmd.def) != docstring::npos)
				add = true;
		} else {
			FullEnvironment const & env =
				possible_textclass_environments[name];
			if (preamble.find(env.beg) != docstring::npos &&
			    preamble.find(env.end) != docstring::npos)
				add = true;
		}
		if (add) {
			FileName layout_file = libFileSearch("layouts", module, "module");
			if (textclass.read(layout_file, TextClass::MODULE)) {
				used_modules.push_back(module);
				// speed up further searches:
				// the module does not need to be checked anymore.
				modules.erase(it);
				return true;
			}
		}
	}
	failed[command].insert(name);
	return false;
}

/// \brief Collect the set of header includes needed to construct the given 
/// module and update the TopHeaders file set of the module.
///
/// \param Module The module we're collecting includes from.
///
/// \param Includes Will be augmented with the set of \#includes or \#imports
/// needed to load all of the named headers.
static std::error_code
collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr,
                            ModuleMap &ModMap, clang::Module *Module,
                            SmallVectorImpl<char> &Includes) {
  // Don't collect any headers for unavailable modules.
  if (!Module->isAvailable())
    return std::error_code();

  // Add includes for each of these headers.
  for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
    for (Module::Header &H : Module->Headers[HK]) {
      Module->addTopHeader(H.Entry);
      // Use the path as specified in the module map file. We'll look for this
      // file relative to the module build directory (the directory containing
      // the module map file) so this will find the same file that we found
      // while parsing the module map.
      addHeaderInclude(H.NameAsWritten, Includes, LangOpts, Module->IsExternC);
    }
  }
  // Note that Module->PrivateHeaders will not be a TopHeader.

  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
    Module->addTopHeader(UmbrellaHeader.Entry);
    if (Module->Parent)
      // Include the umbrella header for submodules.
      addHeaderInclude(UmbrellaHeader.NameAsWritten, Includes, LangOpts,
                       Module->IsExternC);
  } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
    // Add all of the headers we find in this subdirectory.
    std::error_code EC;
    SmallString<128> DirNative;
    llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);

    vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
    for (vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
         Dir != End && !EC; Dir.increment(EC)) {
      // Check whether this entry has an extension typically associated with 
      // headers.
      if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->getName()))
          .Cases(".h", ".H", ".hh", ".hpp", true)
          .Default(false))
        continue;

      const FileEntry *Header = FileMgr.getFile(Dir->getName());
      // FIXME: This shouldn't happen unless there is a file system race. Is
      // that worth diagnosing?
      if (!Header)
        continue;

      // If this header is marked 'unavailable' in this module, don't include 
      // it.
      if (ModMap.isHeaderUnavailableInModule(Header, Module))
        continue;

      // Compute the relative path from the directory to this file.
      SmallVector<StringRef, 16> Components;
      auto PathIt = llvm::sys::path::rbegin(Dir->getName());
      for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
        Components.push_back(*PathIt);
      SmallString<128> RelativeHeader(UmbrellaDir.NameAsWritten);
      for (auto It = Components.rbegin(), End = Components.rend(); It != End;
           ++It)
        llvm::sys::path::append(RelativeHeader, *It);

      // Include this header as part of the umbrella directory.
      Module->addTopHeader(Header);
      addHeaderInclude(RelativeHeader, Includes, LangOpts, Module->IsExternC);
    }

    if (EC)
      return EC;
  }

  // Recurse into submodules.
  for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
                                      SubEnd = Module->submodule_end();
       Sub != SubEnd; ++Sub)
    if (std::error_code Err = collectModuleHeaderIncludes(
            LangOpts, FileMgr, ModMap, *Sub, Includes))
      return Err;

  return std::error_code();
}