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	/////////////////////////////////////////////////////////////////////////////
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	}