libs/modulesystem/modulesmap.h

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #if !defined( INCLUDED_MODULESYSTEM_MODULESMAP_H )
  23 #define INCLUDED_MODULESYSTEM_MODULESMAP_H
  24
  25 #include "modulesystem.h"
  26 #include "string/string.h"
  27 #include <map>
  28 #include <set>
  29
  30 template<typename Type>
  31 class ModulesMap : public Modules<Type>
  32 {
  33 typedef std::map<CopiedString, Module*> modules_t;
  34 modules_t m_modules;
  35 public:
  36 ~ModulesMap(){
  37         for ( modules_t::iterator i = m_modules.begin(); i != m_modules.end(); ++i )
  38         {
  39                 ( *i ).second->release();
  40         }
  41 }
  42
  43 typedef modules_t::const_iterator iterator;
  44
  45 iterator begin() const {
  46         return m_modules.begin();
  47 }
  48 iterator end() const {
  49         return m_modules.end();
  50 }
  51
  52 void insert( const char* name, Module& module ){
  53         module.capture();
  54         if ( globalModuleServer().getError() ) {
  55                 module.release();
  56                 globalModuleServer().setError( false );
  57         }
  58         else
  59         {
  60                 m_modules.insert( modules_t::value_type( name, &module ) );
  61         }
  62 }
  63
  64 Type* find( const char* name ){
  65         modules_t::iterator i = m_modules.find( name );
  66         if ( i != m_modules.end() ) {
  67                 return static_cast<Type*>( Module_getTable( *( *i ).second ) );
  68         }
  69         return 0;
  70 }
  71
  72 Type* findModule( const char* name ){
  73         return find( name );
  74 }
  75 void foreachModule( const typename Modules<Type>::Visitor& visitor ){
  76         for ( modules_t::iterator i = m_modules.begin(); i != m_modules.end(); ++i )
  77         {
  78                 visitor.visit( ( *i ).first.c_str(), *static_cast<const Type*>( Module_getTable( *( *i ).second ) ) );
  79         }
  80 }
  81 };
  82
  83 template<typename Type>
  84 class InsertModules : public ModuleServer::Visitor
  85 {
  86 ModulesMap<Type>& m_modules;
  87 public:
  88 InsertModules( ModulesMap<Type>& modules )
  89         : m_modules( modules ){
  90 }
  91 void visit( const char* name, Module& module ) const {
  92         m_modules.insert( name, module );
  93 }
  94 };
  95
  96 template<typename Type>
  97 class ModulesRef
  98 {
  99 ModulesMap<Type> m_modules;
 100 public:
 101 ModulesRef( const char* names ){
 102         if ( !globalModuleServer().getError() ) {
 103                 if ( string_equal( names, "*" ) ) {
 104                         InsertModules<Type> visitor( m_modules );
 105                         globalModuleServer().foreachModule( typename Type::Name(), typename Type::Version(), visitor );
 106                 }
 107                 else
 108                 {
 109                         StringTokeniser tokeniser( names );
 110                         for (;; )
 111                         {
 112                                 const char* name = tokeniser.getToken();
 113                                 if ( string_empty( name ) ) {
 114                                         break;
 115                                 }
 116                                 Module* module = globalModuleServer().findModule( typename Type::Name(), typename Type::Version(), name );
 117                                 if ( module == 0 ) {
 118                                         globalModuleServer().setError( true );
 119                                         globalErrorStream() << "ModulesRef::initialise: type=" << makeQuoted( typename Type::Name() ) << " version=" << makeQuoted( typename Type::Version() ) << " name=" << makeQuoted( name ) << " - not found\n";
 120                                         break;
 121                                 }
 122                                 else
 123                                 {
 124                                         m_modules.insert( name, *module );
 125                                 }
 126                         }
 127                 }
 128         }
 129 }
 130 ModulesMap<Type>& get(){
 131         return m_modules;
 132 }
 133 };
 134
 135 #endif