← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/registry.cc

  • Committer: lbieber
  • Date: 2010-09-11 16:33:45 UTC
  • mfrom: (1757.1.2 build)
  • Revision ID: lbieber@orisndriz03-20100911163345-na1t8m18at9thsjl
Merge Vijay - added utf 8 tamil test case suite and test case for creating a database in tamil
Merge Brian - Small set of refactoring (includes one case of memset on a table object).

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/registry.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
25
25
 
26
26
#include "drizzled/module/registry.h"
27
27
#include "drizzled/module/library.h"
28
 
#include "drizzled/module/graph.h"
29
 
#include "drizzled/module/vertex_handle.h"
30
28
 
31
29
#include "drizzled/plugin.h"
32
30
#include "drizzled/show.h"
33
31
#include "drizzled/cursor.h"
34
 
#include "drizzled/abort_exception.h"
35
 
 
36
 
#include <boost/bind.hpp>
37
32
 
38
33
using namespace std;
39
34
 
40
35
namespace drizzled
41
36
{
42
37
 
43
 
module::Registry::Registry() :
44
 
  module_registry_(),
45
 
  depend_graph_(new module::Graph()),
46
 
  plugin_registry(),
47
 
  deps_built_(false)
48
 
{ }
49
 
 
50
38
 
51
39
module::Registry::~Registry()
52
40
{
53
 
  plugin::Plugin::map::iterator plugin_iter;
54
 
 
55
 
  /* Give all plugins a chance to cleanup, before
56
 
   * all plugins are deleted.
57
 
   * This can be used if shutdown code references
58
 
   * other plugins.
59
 
   */
60
 
  plugin_iter= plugin_registry.begin();
61
 
  while (plugin_iter != plugin_registry.end())
62
 
  {
63
 
    (*plugin_iter).second->shutdownPlugin();
64
 
    ++plugin_iter;
65
 
  }
66
 
 
67
 
  plugin::Plugin::vector error_plugins;
68
 
  plugin_iter= plugin_registry.begin();
69
 
  while (plugin_iter != plugin_registry.end())
70
 
  {
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
 
    }
79
 
    ++plugin_iter;
80
 
  }
81
 
 
82
 
  for (plugin::Plugin::vector::iterator iter= error_plugins.begin();
83
 
       iter != error_plugins.end(); iter++)
84
 
  {
85
 
    delete *iter;
86
 
  }
87
 
 
 
41
  map<string, plugin::Plugin *>::iterator plugin_iter= plugin_registry.begin();
 
42
  while (plugin_iter != plugin_registry.end())
 
43
  {
 
44
    delete (*plugin_iter).second;
 
45
    ++plugin_iter;
 
46
  }
88
47
  plugin_registry.clear();
89
48
 
90
 
#if 0
91
 
  @TODO When we delete modules here, we segfault on a bad string. Why?
92
 
   ModuleMap::iterator module_iter= module_registry_.begin();
93
 
 
94
 
  while (module_iter != module_registry_.end())
 
49
  /*
 
50
    @TODO When we delete modules here, we segfault on a bad string. Why?
 
51
    map<string, module::Module *>::iterator module_iter= module_map.begin();
 
52
  while (module_iter != module_map.end())
95
53
  {
96
54
    delete (*module_iter).second;
97
55
    ++module_iter;
98
56
  }
99
 
  module_registry_.clear();
100
 
#endif
101
 
  LibraryMap::iterator library_iter= library_registry_.begin();
102
 
  while (library_iter != library_registry_.end())
 
57
  module_map.clear();
 
58
  */
 
59
  map<string, module::Library *>::iterator library_iter= library_map.begin();
 
60
  while (library_iter != library_map.end())
103
61
  {
104
62
    delete (*library_iter).second;
105
63
    ++library_iter;
106
64
  }
107
 
  library_registry_.clear();
 
65
  library_map.clear();
108
66
}
109
67
 
110
68
void module::Registry::shutdown()
113
71
  delete &registry;
114
72
}
115
73
 
116
 
module::Module *module::Registry::find(std::string name)
 
74
module::Module *module::Registry::find(string name)
117
75
{
118
 
  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 
76
  transform(name.begin(), name.end(), name.begin(), ::tolower);
119
77
 
120
 
  ModuleMap::iterator map_iter;
121
 
  map_iter= module_registry_.find(name);
122
 
  if (map_iter != module_registry_.end())
 
78
  map<string, module::Module *>::iterator map_iter;
 
79
  map_iter= module_map.find(name);
 
80
  if (map_iter != module_map.end())
123
81
    return (*map_iter).second;
124
 
  return NULL;
 
82
  return(0);
125
83
}
126
84
 
127
85
void module::Registry::add(module::Module *handle)
128
86
{
129
 
  std::string add_str(handle->getName());
 
87
  string add_str(handle->getName());
130
88
  transform(add_str.begin(), add_str.end(),
131
89
            add_str.begin(), ::tolower);
132
90
 
133
 
  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
 
 
 
91
  module_map[add_str]= handle;
141
92
}
142
93
 
143
94
void module::Registry::remove(module::Module *handle)
144
95
{
145
 
  std::string remove_str(handle->getName());
146
 
  std::transform(remove_str.begin(), remove_str.end(),
147
 
                 remove_str.begin(), ::tolower);
148
 
 
149
 
  module_registry_.erase(remove_str);
150
 
}
151
 
 
152
 
void module::Registry::copy(plugin::Plugin::vector &arg)
153
 
{    
154
 
  arg.reserve(plugin_registry.size());
155
 
 
156
 
  std::transform(plugin_registry.begin(),
157
 
                 plugin_registry.end(),
158
 
                 std::back_inserter(arg),
159
 
                 boost::bind(&plugin::Plugin::map::value_type::second, _1) );
160
 
  assert(arg.size() == plugin_registry.size());
161
 
}
162
 
 
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
 
  }
211
 
 
212
 
  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)
220
 
  {
221
 
    Module *mod_ptr= depend_graph_->properties(*i).getModule();
222
 
    if (mod_ptr != NULL)
223
 
    {
224
 
      plugins.push_back(mod_ptr);
225
 
    }  
 
96
  string remove_str(handle->getName());
 
97
  transform(remove_str.begin(), remove_str.end(),
 
98
            remove_str.begin(), ::tolower);
 
99
 
 
100
  module_map.erase(remove_str);
 
101
}
 
102
 
 
103
vector<module::Module *> module::Registry::getList(bool active)
 
104
{
 
105
  module::Module *plugin= NULL;
 
106
 
 
107
  vector<module::Module *> plugins;
 
108
  plugins.reserve(module_map.size());
 
109
 
 
110
  map<string, module::Module *>::iterator map_iter;
 
111
  for (map_iter= module_map.begin();
 
112
       map_iter != module_map.end();
 
113
       map_iter++)
 
114
  {
 
115
    plugin= (*map_iter).second;
 
116
    if (active)
 
117
      plugins.push_back(plugin);
 
118
    else if (plugin->isInited)
 
119
      plugins.push_back(plugin);
226
120
  }
227
121
 
228
122
  return plugins;
229
123
}
230
124
 
231
 
module::Library *module::Registry::addLibrary(const std::string &plugin_name,
 
125
module::Library *module::Registry::addLibrary(const string &plugin_name,
232
126
                                              bool builtin)
233
127
{
234
128
 
243
137
  if (library != NULL)
244
138
  {
245
139
    /* Add this dll to the map */
246
 
    library_registry_.insert(make_pair(plugin_name, library));
 
140
    library_map.insert(make_pair(plugin_name, library));
247
141
  }
248
142
 
249
143
  return library;
250
144
}
251
145
 
252
 
void module::Registry::removeLibrary(const std::string &plugin_name)
 
146
void module::Registry::removeLibrary(const string &plugin_name)
253
147
{
254
 
  std::map<std::string, module::Library *>::iterator iter=
255
 
    library_registry_.find(plugin_name);
256
 
  if (iter != library_registry_.end())
 
148
  map<string, module::Library *>::iterator iter=
 
149
    library_map.find(plugin_name);
 
150
  if (iter != library_map.end())
257
151
  {
258
 
    library_registry_.erase(iter);
 
152
    library_map.erase(iter);
259
153
    delete (*iter).second;
260
154
  }
261
155
}
262
156
 
263
 
module::Library *module::Registry::findLibrary(const std::string &plugin_name) const
 
157
module::Library *module::Registry::findLibrary(const string &plugin_name) const
264
158
{
265
 
  LibraryMap::const_iterator iter= library_registry_.find(plugin_name);
266
 
  if (iter != library_registry_.end())
 
159
  map<string, module::Library *>::const_iterator iter=
 
160
    library_map.find(plugin_name);
 
161
  if (iter != library_map.end())
267
162
    return (*iter).second;
268
163
  return NULL;
269
164
}