moduleManager.h

Public Variables

ModuleManager ModuleDatabase 

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2013 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#ifndef _MODULE_MANAGER_H
 25#define _MODULE_MANAGER_H
 26
 27#ifndef _SIMBASE_H_
 28#include "console/simBase.h"
 29#endif
 30
 31#ifndef _TVECTOR_H_
 32#include "core/util/tvector.h"
 33#endif
 34
 35#ifndef _TDICTIONARY_H_
 36#include "core/util/tDictionary.h"
 37#endif
 38
 39#ifndef _TAML_H_
 40#include "persistence/taml/taml.h"
 41#endif
 42
 43#ifndef _MODULE_DEFINITION_H
 44#include "moduleDefinition.h"
 45#endif
 46
 47//-----------------------------------------------------------------------------
 48
 49#define MODULE_MANAGER_MERGE_FILE                   "module.merge"
 50#define MODULE_MANAGER_MODULE_DEFINITION_EXTENSION  "module.taml"
 51
 52//-----------------------------------------------------------------------------
 53
 54/// @ingroup moduleGroup
 55/// @see moduleGroup
 56class ModuleManager : public SimObject
 57{
 58private:
 59    typedef SimObject Parent;
 60
 61public:
 62    /// Module definitions.
 63    typedef Vector<ModuleDefinition*> typeModuleDefinitionVector;
 64    typedef Vector<const ModuleDefinition*> typeConstModuleDefinitionVector;
 65
 66private:
 67    /// Database locking.
 68    struct LockDatabase
 69    {
 70    public:
 71        LockDatabase( ModuleManager* pManager ) :
 72          mpManager( pManager )
 73          {
 74              mpManager->mDatabaseLocks++;
 75          }
 76
 77        ~LockDatabase()
 78        {
 79            mpManager->mDatabaseLocks--;
 80
 81            // Sanity!
 82            AssertFatal( mpManager->mDatabaseLocks >= 0, "Module Manager: Cannot unlock database as it is already unlocked." );
 83        }
 84
 85    private:
 86        ModuleManager* mpManager;
 87    };
 88
 89    /// Loaded module entry.
 90    struct ModuleLoadEntry
 91    {
 92        ModuleLoadEntry( ModuleDefinition* pModuleDefinition, const bool strictVersionId ) :
 93            mpModuleDefinition( pModuleDefinition ),
 94            mStrictVersionId( strictVersionId )
 95        {
 96        }
 97
 98        ModuleLoadEntry()
 99        {
100           mpModuleDefinition = NULL;
101           mStrictVersionId = false;
102        }
103
104        ModuleDefinition*   mpModuleDefinition;
105        bool                mStrictVersionId;
106    };
107
108    /// Module loading.
109    typedef Vector<StringTableEntry> typeModuleIdVector;
110    typedef Vector<StringTableEntry> typeGroupVector;
111    typedef HashMap<StringTableEntry, typeModuleIdVector*> typeGroupModuleHash;
112    typedef Vector<ModuleLoadEntry> typeModuleLoadEntryVector;
113    typeGroupModuleHash         mGroupModules;
114    typeGroupVector             mGroupsLoaded;
115    typeModuleLoadEntryVector   mModulesLoaded;
116
117    /// Miscellaneous.
118    bool                        mEnforceDependencies;
119    bool                        mEchoInfo;
120    S32                         mDatabaseLocks;
121    char                        mModuleExtension[256];
122    Taml                        mTaml;
123    SimSet                      mNotificationListeners;
124
125    // Module definition entry.
126    struct ModuleDefinitionEntry : public typeModuleDefinitionVector
127    {
128    public:
129        ModuleDefinitionEntry( StringTableEntry moduleId, StringTableEntry moduleGroup, StringTableEntry moduleType ) :
130            mModuleId( moduleId ),
131            mModuleGroup( moduleGroup ),
132            mModuleType( moduleType )
133        {
134        }
135
136        const StringTableEntry  mModuleId;
137        const StringTableEntry  mModuleGroup;
138        const StringTableEntry  mModuleType;
139    };
140
141    /// Module databases.
142    typedef HashMap<StringTableEntry, ModuleDefinitionEntry*> typeModuleIdDatabaseHash;
143    typeModuleIdDatabaseHash mModuleIdDatabase;
144
145public:
146    ModuleManager();
147    virtual ~ModuleManager() {}
148
149    /// SimObject overrides
150    virtual bool onAdd();
151    virtual void onRemove();
152    virtual void onDeleteNotify( SimObject *object );
153    static void initPersistFields();
154
155    /// Declare Console Object.
156    DECLARE_CONOBJECT( ModuleManager );
157
158    /// Module definitions.
159    bool setModuleExtension( const char* pExtension );
160
161    /// Module discovery.
162    bool scanModules( const char* pPath, const bool rootOnly = false );
163
164    /// Module unregister.
165    bool unregisterModule( const char* pModuleId, const U32 versionId );
166
167    /// Module (un)loading.
168    bool loadModuleGroup( const char* pModuleGroup );
169    bool unloadModuleGroup( const char* pModuleGroup );
170    bool loadModuleExplicit( const char* pModuleId, const U32 versionId = 0 );
171    bool unloadModuleExplicit( const char* pModuleId );
172
173    /// Module type enumeration.
174    ModuleDefinition* findModule( const char* pModuleId, const U32 versionId );
175    ModuleDefinition* findLoadedModule( const char* pModuleId );
176    void findModules( const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );
177    void findModuleTypes( const char* pModuleType, const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );
178
179    /// Module synchronization.
180    StringTableEntry copyModule( ModuleDefinition* pSourceModuleDefinition, const char* pTargetModuleId, const char* pTargetPath, const bool useVersionPathing );
181    bool synchronizeDependencies( ModuleDefinition* pRootModuleDefinition, const char* pTargetDependencyPath );
182
183    /// Module updates.
184    inline bool isModuleMergeAvailable( void ) const { return Platform::isFile( getModuleMergeFilePath() ); }
185    bool canMergeModules( const char* pMergeSourcePath );
186    bool mergeModules( const char* pMergeTargetPath, const bool removeMergeDefinition, const bool registerNewModules );
187
188    /// Module notifications.
189    void addListener( SimObject* pListener );
190    void removeListener( SimObject* pListener );
191
192private:
193    void clearDatabase( void );
194    bool removeModuleDefinition( ModuleDefinition* pModuleDefinition );
195    bool registerModule( const char* pModulePath, const char* pModuleFile );
196
197    void raiseModulePreLoadNotifications( ModuleDefinition* pModuleDefinition );
198    void raiseModulePostLoadNotifications( ModuleDefinition* pModuleDefinition );
199    void raiseModulePreUnloadNotifications( ModuleDefinition* pModuleDefinition );
200    void raiseModulePostUnloadNotifications( ModuleDefinition* pModuleDefinition );
201
202    ModuleDefinitionEntry* findModuleId( StringTableEntry moduleId );
203    ModuleDefinitionEntry::iterator findModuleDefinition( StringTableEntry moduleId, const U32 versionId );
204    bool resolveModuleDependencies( StringTableEntry moduleId, const U32 versionId, StringTableEntry moduleGroup, bool synchronizedOnly, typeModuleLoadEntryVector& moduleResolvingQueue, typeModuleLoadEntryVector& moduleReadyQueue );
205    ModuleLoadEntry* findModuleResolving( StringTableEntry moduleId, typeModuleLoadEntryVector& moduleResolvingQueue );
206    ModuleLoadEntry* findModuleReady( StringTableEntry moduleId, typeModuleLoadEntryVector& moduleReadyQueue );
207    typeModuleLoadEntryVector::iterator findModuleLoaded( StringTableEntry moduleId, const U32 versionId = 0 );
208    typeGroupVector::iterator findGroupLoaded( StringTableEntry moduleGroup );
209    StringTableEntry getModuleMergeFilePath( void ) const;
210};
211
212//-----------------------------------------------------------------------------
213
214extern ModuleManager ModuleDatabase;
215
216#endif // _MODULE_MANAGER_H
217