src/common/module.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/module.cpp
// Purpose:     Modules initialization/destruction
// Author:      Wolfram Gloger/adapted by Guilhem Lavaux
// Modified by:
// Created:     04/11/98
// RCS-ID:      $Id: module.cpp 39677 2006-06-11 22:19:12Z VZ $
// Copyright:   (c) Wolfram Gloger and Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/module.h"

#ifndef WX_PRECOMP
    #include "wx/hash.h"
    #include "wx/intl.h"
    #include "wx/log.h"
#endif

#include "wx/listimpl.cpp"

#define TRACE_MODULE _T("module")

WX_DEFINE_LIST(wxModuleList)

IMPLEMENT_CLASS(wxModule, wxObject)

wxModuleList wxModule::m_modules;

void wxModule::RegisterModule(wxModule* module)
{
    module->m_state = State_Registered;
    m_modules.Append(module);
}

void wxModule::UnregisterModule(wxModule* module)
{
    m_modules.DeleteObject(module);
    delete module;
}

// Collect up all module-derived classes, create an instance of each,
// and register them.
void wxModule::RegisterModules()
{
    wxHashTable::compatibility_iterator node;
    wxClassInfo* classInfo;

    wxClassInfo::sm_classTable->BeginFind();
    node = wxClassInfo::sm_classTable->Next();
    while (node)
    {
        classInfo = (wxClassInfo *)node->GetData();
        if ( classInfo->IsKindOf(CLASSINFO(wxModule)) &&
            (classInfo != (& (wxModule::ms_classInfo))) )
        {
            wxLogTrace(TRACE_MODULE, wxT("Registering module %s"),
                       classInfo->GetClassName());
            wxModule* module = (wxModule *)classInfo->CreateObject();
            RegisterModule(module);
        }
        node = wxClassInfo::sm_classTable->Next();
    }
}

bool wxModule::DoInitializeModule(wxModule *module,
                                  wxModuleList &initializedModules)
{
    if ( module->m_state == State_Initializing )
    {
        wxLogError(_("Circular dependency involving module \"%s\" detected."),
                   module->GetClassInfo()->GetClassName());
        return false;
    }

    module->m_state = State_Initializing;

    const wxArrayClassInfo& dependencies = module->m_dependencies;

    // satisfy module dependencies by loading them before the current module
    for ( unsigned int i = 0; i < dependencies.size(); ++i )
    {
        wxClassInfo * cinfo = dependencies[i];

        // Check if the module is already initialized
        wxModuleList::compatibility_iterator node;
        for ( node = initializedModules.GetFirst(); node; node = node->GetNext() )
        {
            if ( node->GetData()->GetClassInfo() == cinfo )
                break;
        }

        if ( node )
        {
            // this dependency is already initialized, nothing to do
            continue;
        }

        // find the module in the registered modules list
        for ( node = m_modules.GetFirst(); node; node = node->GetNext() )
        {
            wxModule *moduleDep = node->GetData();
            if ( moduleDep->GetClassInfo() == cinfo )
            {
                if ( !DoInitializeModule(moduleDep, initializedModules ) )
                {
                    // failed to initialize a dependency, so fail this one too
                    return false;
                }

                break;
            }
        }

        if ( !node )
        {
            wxLogError(_("Dependency \"%s\" of module \"%s\" doesn't exist."),
                       cinfo->GetClassName(),
                       module->GetClassInfo()->GetClassName());
            return false;
        }
    }

    if ( !module->Init() )
    {
        wxLogError(_("Module \"%s\" initialization failed"),
                   module->GetClassInfo()->GetClassName());
        return false;
    }

    wxLogTrace(TRACE_MODULE, wxT("Module \"%s\" initialized"),
               module->GetClassInfo()->GetClassName());

    module->m_state = State_Initialized;
    initializedModules.Append(module);

    return true;
}

// Initialize user-defined modules
bool wxModule::InitializeModules()
{
    wxModuleList initializedModules;

    for ( wxModuleList::compatibility_iterator node = m_modules.GetFirst();
          node;
          node = node->GetNext() )
    {
        wxModule *module = node->GetData();

        // the module could have been already initialized as dependency of
        // another one
        if ( module->m_state == State_Registered )
        {
            if ( !DoInitializeModule( module, initializedModules ) )
            {
                // failed to initialize all modules, so clean up the already
                // initialized ones
                DoCleanUpModules(initializedModules);

                return false;
            }
        }
    }

    // remember the real initialisation order
    m_modules = initializedModules;

    return true;
}

// Clean up all currently initialized modules
void wxModule::DoCleanUpModules(const wxModuleList& modules)
{
    // cleanup user-defined modules in the reverse order compared to their
    // initialization -- this ensures that dependencies are respected
    for ( wxModuleList::compatibility_iterator node = modules.GetLast();
          node;
          node = node->GetPrevious() )
    {
        wxLogTrace(TRACE_MODULE, wxT("Cleanup module %s"),
                   node->GetData()->GetClassInfo()->GetClassName());

        wxModule * module = node->GetData();

        wxASSERT_MSG( module->m_state == State_Initialized,
                        _T("not initialized module being cleaned up") );

        module->Exit();
        module->m_state = State_Registered;
    }

    // clear all modules, even the non-initialized ones
    WX_CLEAR_LIST(wxModuleList, m_modules);
}
1	william	31	/////////////////////////////////////////////////////////////////////////////
2			// Name: src/common/module.cpp
3			// Purpose: Modules initialization/destruction
4			// Author: Wolfram Gloger/adapted by Guilhem Lavaux
5			// Modified by:
6			// Created: 04/11/98
7			// RCS-ID: $Id: module.cpp 39677 2006-06-11 22:19:12Z VZ $
8			// Copyright: (c) Wolfram Gloger and Guilhem Lavaux
9			// Licence: wxWindows licence
10			/////////////////////////////////////////////////////////////////////////////
11
12			// For compilers that support precompilation, includes "wx.h".
13			#include "wx/wxprec.h"
14
15			#ifdef __BORLANDC__
16			#pragma hdrstop
17			#endif
18
19			#include "wx/module.h"
20
21			#ifndef WX_PRECOMP
22			#include "wx/hash.h"
23			#include "wx/intl.h"
24			#include "wx/log.h"
25			#endif
26
27			#include "wx/listimpl.cpp"
28
29			#define TRACE_MODULE _T("module")
30
31			WX_DEFINE_LIST(wxModuleList)
32
33			IMPLEMENT_CLASS(wxModule, wxObject)
34
35			wxModuleList wxModule::m_modules;
36
37			void wxModule::RegisterModule(wxModule* module)
38			{
39			module->m_state = State_Registered;
40			m_modules.Append(module);
41			}
42
43			void wxModule::UnregisterModule(wxModule* module)
44			{
45			m_modules.DeleteObject(module);
46			delete module;
47			}
48
49			// Collect up all module-derived classes, create an instance of each,
50			// and register them.
51			void wxModule::RegisterModules()
52			{
53			wxHashTable::compatibility_iterator node;
54			wxClassInfo* classInfo;
55
56			wxClassInfo::sm_classTable->BeginFind();
57			node = wxClassInfo::sm_classTable->Next();
58			while (node)
59			{
60			classInfo = (wxClassInfo *)node->GetData();
61			if ( classInfo->IsKindOf(CLASSINFO(wxModule)) &&
62			(classInfo != (& (wxModule::ms_classInfo))) )
63			{
64			wxLogTrace(TRACE_MODULE, wxT("Registering module %s"),
65			classInfo->GetClassName());
66			wxModule* module = (wxModule *)classInfo->CreateObject();
67			RegisterModule(module);
68			}
69			node = wxClassInfo::sm_classTable->Next();
70			}
71			}
72
73			bool wxModule::DoInitializeModule(wxModule *module,
74			wxModuleList &initializedModules)
75			{
76			if ( module->m_state == State_Initializing )
77			{
78			wxLogError(_("Circular dependency involving module \"%s\" detected."),
79			module->GetClassInfo()->GetClassName());
80			return false;
81			}
82
83			module->m_state = State_Initializing;
84
85			const wxArrayClassInfo& dependencies = module->m_dependencies;
86
87			// satisfy module dependencies by loading them before the current module
88			for ( unsigned int i = 0; i < dependencies.size(); ++i )
89			{
90			wxClassInfo * cinfo = dependencies[i];
91
92			// Check if the module is already initialized
93			wxModuleList::compatibility_iterator node;
94			for ( node = initializedModules.GetFirst(); node; node = node->GetNext() )
95			{
96			if ( node->GetData()->GetClassInfo() == cinfo )
97			break;
98			}
99
100			if ( node )
101			{
102			// this dependency is already initialized, nothing to do
103			continue;
104			}
105
106			// find the module in the registered modules list
107			for ( node = m_modules.GetFirst(); node; node = node->GetNext() )
108			{
109			wxModule *moduleDep = node->GetData();
110			if ( moduleDep->GetClassInfo() == cinfo )
111			{
112			if ( !DoInitializeModule(moduleDep, initializedModules ) )
113			{
114			// failed to initialize a dependency, so fail this one too
115			return false;
116			}
117
118			break;
119			}
120			}
121
122			if ( !node )
123			{
124			wxLogError(_("Dependency \"%s\" of module \"%s\" doesn't exist."),
125			cinfo->GetClassName(),
126			module->GetClassInfo()->GetClassName());
127			return false;
128			}
129			}
130
131			if ( !module->Init() )
132			{
133			wxLogError(_("Module \"%s\" initialization failed"),
134			module->GetClassInfo()->GetClassName());
135			return false;
136			}
137
138			wxLogTrace(TRACE_MODULE, wxT("Module \"%s\" initialized"),
139			module->GetClassInfo()->GetClassName());
140
141			module->m_state = State_Initialized;
142			initializedModules.Append(module);
143
144			return true;
145			}
146
147			// Initialize user-defined modules
148			bool wxModule::InitializeModules()
149			{
150			wxModuleList initializedModules;
151
152			for ( wxModuleList::compatibility_iterator node = m_modules.GetFirst();
153			node;
154			node = node->GetNext() )
155			{
156			wxModule *module = node->GetData();
157
158			// the module could have been already initialized as dependency of
159			// another one
160			if ( module->m_state == State_Registered )
161			{
162			if ( !DoInitializeModule( module, initializedModules ) )
163			{
164			// failed to initialize all modules, so clean up the already
165			// initialized ones
166			DoCleanUpModules(initializedModules);
167
168			return false;
169			}
170			}
171			}
172
173			// remember the real initialisation order
174			m_modules = initializedModules;
175
176			return true;
177			}
178
179			// Clean up all currently initialized modules
180			void wxModule::DoCleanUpModules(const wxModuleList& modules)
181			{
182			// cleanup user-defined modules in the reverse order compared to their
183			// initialization -- this ensures that dependencies are respected
184			for ( wxModuleList::compatibility_iterator node = modules.GetLast();
185			node;
186			node = node->GetPrevious() )
187			{
188			wxLogTrace(TRACE_MODULE, wxT("Cleanup module %s"),
189			node->GetData()->GetClassInfo()->GetClassName());
190
191			wxModule * module = node->GetData();
192
193			wxASSERT_MSG( module->m_state == State_Initialized,
194			_T("not initialized module being cleaned up") );
195
196			module->Exit();
197			module->m_state = State_Registered;
198			}
199
200			// clear all modules, even the non-initialized ones
201			WX_CLEAR_LIST(wxModuleList, m_modules);
202			}