← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Brian Aker
  • Date: 2010-08-06 01:25:55 UTC
  • mfrom: (1688.1.3 drizzle)
  • Revision ID: brian@gaz-20100806012555-f1bxjm4iesdtiwlw
Merge Build (rollup)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
55
55
#include <drizzled/table_proto.h>
56
56
#include <drizzled/plugin/event_observer.h>
57
57
 
 
58
#include <boost/algorithm/string/compare.hpp>
 
59
 
58
60
static bool shutdown_has_begun= false; // Once we put in the container for the vector/etc for engines this will go away.
59
61
 
60
62
using namespace std;
68
70
static EngineVector vector_of_engines;
69
71
static EngineVector vector_of_schema_engines;
70
72
 
 
73
const std::string DEFAULT_STRING("default");
71
74
const std::string UNKNOWN_STRING("UNKNOWN");
72
75
const std::string DEFAULT_DEFINITION_FILE_EXT(".dfe");
73
76
 
190
193
class FindEngineByName
191
194
  : public unary_function<StorageEngine *, bool>
192
195
{
193
 
  const string &target;
 
196
  const string &predicate;
194
197
 
195
198
public:
196
199
  explicit FindEngineByName(const string &target_arg) :
197
 
    target(target_arg)
 
200
    predicate(target_arg)
198
201
  {
199
202
  }
 
203
 
200
204
  result_type operator() (argument_type engine)
201
205
  {
202
 
    string engine_name(engine->getName());
203
 
 
204
 
    transform(engine_name.begin(), engine_name.end(),
205
 
              engine_name.begin(), ::tolower);
206
 
    return engine_name == target;
 
206
    return boost::iequals(engine->getName(), predicate);
207
207
  }
208
208
};
209
209
 
210
 
StorageEngine *StorageEngine::findByName(const string &find_str)
 
210
StorageEngine *StorageEngine::findByName(const string &predicate)
211
211
{
212
 
  string search_string(find_str);
213
 
  transform(search_string.begin(), search_string.end(),
214
 
            search_string.begin(), ::tolower);
215
 
 
216
 
  
217
212
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
218
213
                                       vector_of_engines.end(),
219
 
                                       FindEngineByName(search_string));
 
214
                                       FindEngineByName(predicate));
220
215
  if (iter != vector_of_engines.end())
221
216
  {
222
217
    StorageEngine *engine= *iter;
227
222
  return NULL;
228
223
}
229
224
 
230
 
StorageEngine *StorageEngine::findByName(Session& session, const string &find_str)
 
225
StorageEngine *StorageEngine::findByName(Session& session, const string &predicate)
231
226
{
232
 
  string search_string(find_str);
233
 
  transform(search_string.begin(), search_string.end(),
234
 
            search_string.begin(), ::tolower);
235
 
 
236
 
  if (search_string.compare("default") == 0)
 
227
  if (boost::iequals(predicate, DEFAULT_STRING))
237
228
    return session.getDefaultStorageEngine();
238
229
 
239
230
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
240
231
                                       vector_of_engines.end(),
241
 
                                       FindEngineByName(search_string));
 
232
                                       FindEngineByName(predicate));
242
233
  if (iter != vector_of_engines.end())
243
234
  {
244
235
    StorageEngine *engine= *iter;