← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/registry.cc

  • Committer: Monty Taylor
  • Date: 2010-12-05 07:35:32 UTC
  • mfrom: (1974 b)
  • mto: (1975.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1976.
  • Revision ID: mordred@inaugust.com-20101205073532-hehqwv27pbd7byjm
Merged source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/registry.cc
30
30
#include "drizzled/show.h"
31
31
#include "drizzled/cursor.h"
32
32
 
 
33
#include <boost/bind.hpp>
 
34
 
33
35
using namespace std;
34
36
 
35
37
namespace drizzled
38
40
 
39
41
module::Registry::~Registry()
40
42
{
41
 
  map<string, plugin::Plugin *>::iterator plugin_iter;
 
43
  std::map<std::string, plugin::Plugin *>::iterator plugin_iter;
42
44
 
43
45
  /* Give all plugins a chance to cleanup, before
44
46
   * all plugins are deleted.
60
62
  }
61
63
  plugin_registry.clear();
62
64
 
63
 
  /*
64
 
    @TODO When we delete modules here, we segfault on a bad string. Why?
 
65
#if 0
 
66
  @TODO When we delete modules here, we segfault on a bad string. Why?
65
67
    map<string, module::Module *>::iterator module_iter= module_map.begin();
 
68
 
66
69
  while (module_iter != module_map.end())
67
70
  {
68
71
    delete (*module_iter).second;
69
72
    ++module_iter;
70
73
  }
71
74
  module_map.clear();
72
 
  */
73
 
  map<string, module::Library *>::iterator library_iter= library_map.begin();
 
75
#endif
 
76
  std::map<std::string, module::Library *>::iterator library_iter= library_map.begin();
74
77
  while (library_iter != library_map.end())
75
78
  {
76
79
    delete (*library_iter).second;
85
88
  delete &registry;
86
89
}
87
90
 
88
 
module::Module *module::Registry::find(string name)
 
91
module::Module *module::Registry::find(std::string name)
89
92
{
90
 
  transform(name.begin(), name.end(), name.begin(), ::tolower);
 
93
  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
91
94
 
92
 
  map<string, module::Module *>::iterator map_iter;
 
95
  std::map<std::string, module::Module *>::iterator map_iter;
93
96
  map_iter= module_map.find(name);
94
97
  if (map_iter != module_map.end())
95
98
    return (*map_iter).second;
98
101
 
99
102
void module::Registry::add(module::Module *handle)
100
103
{
101
 
  string add_str(handle->getName());
 
104
  std::string add_str(handle->getName());
102
105
  transform(add_str.begin(), add_str.end(),
103
106
            add_str.begin(), ::tolower);
104
107
 
107
110
 
108
111
void module::Registry::remove(module::Module *handle)
109
112
{
110
 
  string remove_str(handle->getName());
111
 
  transform(remove_str.begin(), remove_str.end(),
112
 
            remove_str.begin(), ::tolower);
 
113
  std::string remove_str(handle->getName());
 
114
  std::transform(remove_str.begin(), remove_str.end(),
 
115
                 remove_str.begin(), ::tolower);
113
116
 
114
117
  module_map.erase(remove_str);
115
118
}
116
119
 
 
120
void module::Registry::copy(plugin::Plugin::vector &arg)
 
121
{    
 
122
  arg.reserve(plugin_registry.size());
 
123
 
 
124
  std::transform(plugin_registry.begin(),
 
125
                 plugin_registry.end(),
 
126
                 std::back_inserter(arg),
 
127
                 boost::bind(&plugin::Plugin::map::value_type::second, _1) );
 
128
  assert(arg.size() == plugin_registry.size());
 
129
}
 
130
 
117
131
vector<module::Module *> module::Registry::getList(bool active)
118
132
{
119
133
  module::Module *plugin= NULL;
120
134
 
121
 
  vector<module::Module *> plugins;
 
135
  std::vector<module::Module *> plugins;
122
136
  plugins.reserve(module_map.size());
123
137
 
124
 
  map<string, module::Module *>::iterator map_iter;
 
138
  std::map<std::string, module::Module *>::iterator map_iter;
125
139
  for (map_iter= module_map.begin();
126
140
       map_iter != module_map.end();
127
141
       map_iter++)
136
150
  return plugins;
137
151
}
138
152
 
139
 
module::Library *module::Registry::addLibrary(const string &plugin_name,
 
153
module::Library *module::Registry::addLibrary(const std::string &plugin_name,
140
154
                                              bool builtin)
141
155
{
142
156
 
157
171
  return library;
158
172
}
159
173
 
160
 
void module::Registry::removeLibrary(const string &plugin_name)
 
174
void module::Registry::removeLibrary(const std::string &plugin_name)
161
175
{
162
 
  map<string, module::Library *>::iterator iter=
 
176
  std::map<std::string, module::Library *>::iterator iter=
163
177
    library_map.find(plugin_name);
164
178
  if (iter != library_map.end())
165
179
  {
168
182
  }
169
183
}
170
184
 
171
 
module::Library *module::Registry::findLibrary(const string &plugin_name) const
 
185
module::Library *module::Registry::findLibrary(const std::string &plugin_name) const
172
186
{
173
 
  map<string, module::Library *>::const_iterator iter=
 
187
  std::map<std::string, module::Library *>::const_iterator iter=
174
188
    library_map.find(plugin_name);
175
189
  if (iter != library_map.end())
176
190
    return (*iter).second;