← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/registry.cc

  • Committer: Brian Aker
  • Date: 2011-01-12 06:45:23 UTC
  • mto: (2073.1.4 catalogs)
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: brian@tangent.org-20110112064523-rqhptaqbph22qmj1
Remove custom error.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/registry.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <config.h>
 
20
#include "config.h"
21
21
 
22
22
#include <string>
23
23
#include <vector>
24
24
#include <map>
25
25
 
26
 
#include <drizzled/module/registry.h>
27
 
#include <drizzled/module/library.h>
28
 
#include <drizzled/module/graph.h>
29
 
#include <drizzled/module/vertex_handle.h>
 
26
#include "drizzled/module/registry.h"
 
27
#include "drizzled/module/library.h"
30
28
 
31
 
#include <drizzled/plugin.h>
32
 
#include <drizzled/show.h>
33
 
#include <drizzled/cursor.h>
34
 
#include <drizzled/abort_exception.h>
 
29
#include "drizzled/plugin.h"
 
30
#include "drizzled/show.h"
 
31
#include "drizzled/cursor.h"
35
32
 
36
33
#include <boost/bind.hpp>
37
34
 
40
37
namespace drizzled
41
38
{
42
39
 
43
 
module::Registry::Registry() :
44
 
  module_registry_(),
45
 
  depend_graph_(new module::Graph()),
46
 
  plugin_registry(),
47
 
  deps_built_(false)
48
 
{ }
49
 
 
50
40
 
51
41
module::Registry::~Registry()
52
42
{
64
54
    ++plugin_iter;
65
55
  }
66
56
 
67
 
  plugin::Plugin::vector error_plugins;
68
57
  plugin_iter= plugin_registry.begin();
69
58
  while (plugin_iter != plugin_registry.end())
70
59
  {
71
 
    if ((*plugin_iter).second->removeLast())
72
 
    {
73
 
      error_plugins.push_back((*plugin_iter).second);
74
 
    }
75
 
    else
76
 
    {
77
 
      delete (*plugin_iter).second;
78
 
    }
 
60
    delete (*plugin_iter).second;
79
61
    ++plugin_iter;
80
62
  }
81
 
 
82
 
  for (plugin::Plugin::vector::iterator iter= error_plugins.begin();
83
 
       iter != error_plugins.end(); iter++)
84
 
  {
85
 
    delete *iter;
86
 
  }
87
 
 
88
63
  plugin_registry.clear();
89
64
 
90
65
#if 0
121
96
  map_iter= module_registry_.find(name);
122
97
  if (map_iter != module_registry_.end())
123
98
    return (*map_iter).second;
124
 
  return NULL;
 
99
  return(0);
125
100
}
126
101
 
127
102
void module::Registry::add(module::Module *handle)
131
106
            add_str.begin(), ::tolower);
132
107
 
133
108
  module_registry_[add_str]= handle;
134
 
 
135
 
  Vertex vertex_info(add_str, handle);
136
 
  VertexDesc handle_vertex= boost::add_vertex(depend_graph_->getGraph());
137
 
  depend_graph_->properties(handle_vertex)= vertex_info;
138
 
 
139
 
  handle->setVertexHandle(new VertexHandle(handle_vertex));
140
 
 
141
109
}
142
110
 
143
111
void module::Registry::remove(module::Module *handle)
160
128
  assert(arg.size() == plugin_registry.size());
161
129
}
162
130
 
163
 
void module::Registry::buildDeps()
164
 
{
165
 
  ModuleMap::iterator map_iter= module_registry_.begin();
166
 
  while (map_iter != module_registry_.end())
167
 
  {
168
 
    Module *handle= (*map_iter).second;
169
 
    Module::Depends::const_iterator handle_deps= handle->getDepends().begin();
170
 
    while (handle_deps != handle->getDepends().end())
171
 
    {
172
 
      std::string dep_str((*handle_deps));
173
 
      transform(dep_str.begin(), dep_str.end(),
174
 
                dep_str.begin(), ::tolower);
175
 
 
176
 
      bool found_dep= false;
177
 
      vertex_iter it= boost::vertices(depend_graph_->getGraph()).first;
178
 
      while (it != vertices(depend_graph_->getGraph()).second)
179
 
      {
180
 
        if (depend_graph_->properties(*it).getName() == dep_str)
181
 
        {
182
 
          found_dep= true;
183
 
          add_edge(handle->getVertexHandle()->getVertexDesc(), *it, depend_graph_->getGraph());
184
 
          break;
185
 
        }
186
 
        ++it;
187
 
      }
188
 
      if (not found_dep)
189
 
      {
190
 
        errmsg_printf(error::ERROR,
191
 
                      _("Couldn't process plugin module dependencies. "
192
 
                        "%s depends on %s but %s is not to be loaded.\n"),
193
 
                      handle->getName().c_str(),
194
 
                      dep_str.c_str(), dep_str.c_str());
195
 
        DRIZZLE_ABORT;
196
 
      }
197
 
 
198
 
      ++handle_deps;
199
 
    }
200
 
    ++map_iter;
201
 
  }
202
 
  deps_built_= true;
203
 
}
204
 
 
205
 
module::Registry::ModuleList module::Registry::getList()
206
 
{
207
 
  if (not deps_built_)
208
 
  {
209
 
    buildDeps();
210
 
  }
 
131
vector<module::Module *> module::Registry::getList(bool active)
 
132
{
 
133
  module::Module *plugin= NULL;
211
134
 
212
135
  std::vector<module::Module *> plugins;
213
 
 
214
 
  VertexList vertex_list;
215
 
 
216
 
  boost::topological_sort(depend_graph_->getGraph(), std::back_inserter(vertex_list));
217
 
 
218
 
  for (VertexList::iterator i = vertex_list.begin();
219
 
       i != vertex_list.end(); ++i)
 
136
  plugins.reserve(module_registry_.size());
 
137
 
 
138
  ModuleMap::iterator map_iter;
 
139
  for (map_iter= module_registry_.begin();
 
140
       map_iter != module_registry_.end();
 
141
       map_iter++)
220
142
  {
221
 
    Module *mod_ptr= depend_graph_->properties(*i).getModule();
222
 
    if (mod_ptr != NULL)
223
 
    {
224
 
      plugins.push_back(mod_ptr);
225
 
    }  
 
143
    plugin= (*map_iter).second;
 
144
    if (active)
 
145
      plugins.push_back(plugin);
 
146
    else if (plugin->isInited)
 
147
      plugins.push_back(plugin);
226
148
  }
227
149
 
228
150
  return plugins;