← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/catalog/cache.cc

  • Committer: Brian Aker
  • Date: 2011-02-27 19:43:52 UTC
  • mfrom: (2192.4.9 iter)
  • Revision ID: brian@tangent.org-20110227194352-w48j3ey8nhonecsd
Merge in find_ptr

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/catalog/cache.cc
21
21
#include <config.h>
22
22
 
23
23
#include <drizzled/catalog/cache.h>
 
24
#include <drizzled/util/find_ptr.h>
24
25
 
25
26
namespace drizzled {
26
27
namespace catalog {
28
29
Instance::shared_ptr Cache::find(const identifier::Catalog &identifier, drizzled::error_t &error)
29
30
{
30
31
  boost::mutex::scoped_lock scopedLock(_mutex);
31
 
  unordered_map::iterator iter= cache.find(identifier);
32
 
  if (iter != cache.end())
 
32
  if (const unordered_map::mapped_type* ptr= find_ptr(cache, identifier))
33
33
  {
34
 
    if (not (*iter).second)
35
 
    {
36
 
      error= ER_CATALOG_NO_LOCK;
37
 
    }
38
 
    else
39
 
    {
40
 
      error= EE_OK;
41
 
    }
42
 
 
43
 
    return (*iter).second;
 
34
    error= *ptr ? EE_OK : ER_CATALOG_NO_LOCK;
 
35
    return *ptr;
44
36
  }
45
 
 
46
37
  error= ER_CATALOG_DOES_NOT_EXIST;
47
38
  return catalog::Instance::shared_ptr();
48
39
}
50
41
bool Cache::exist(const identifier::Catalog &identifier)
51
42
{
52
43
  boost::mutex::scoped_lock scopedLock(_mutex);
53
 
  unordered_map::iterator iter= cache.find(identifier);
54
 
  if (iter != cache.end())
55
 
  {
56
 
    return true;
57
 
  }
58
 
 
59
 
  return false;
 
44
  return find_ptr(cache, identifier);
60
45
}
61
46
 
62
47
bool Cache::erase(const identifier::Catalog &identifier, drizzled::error_t &error)
63
48
{
64
49
  boost::mutex::scoped_lock scopedLock(_mutex);
65
 
 
66
 
  unordered_map::iterator iter= cache.find(identifier);
67
 
  if (iter != cache.end())
 
50
  if (find_ptr(cache, identifier))
68
51
  {
69
 
    unordered_map::size_type erased= cache.erase(identifier);
70
 
 
71
 
    if (erased)
 
52
    if (cache.erase(identifier))
72
53
      return true;
73
 
 
74
 
    assert(0); // This should be imposssible
 
54
    assert(false); // This should be imposssible
75
55
  }
76
56
  error= ER_CATALOG_DOES_NOT_EXIST;
77
 
 
78
57
  return false;
79
58
}
80
59
 
81
60
bool Cache::unlock(const identifier::Catalog &identifier, drizzled::error_t &error)
82
61
{
83
62
  boost::mutex::scoped_lock scopedLock(_mutex);
84
 
 
85
 
  unordered_map::iterator iter= cache.find(identifier);
86
 
  if (iter != cache.end())
 
63
  if (const unordered_map::mapped_type* ptr= find_ptr(cache, identifier))
87
64
  {
88
 
    if (not (*iter).second)
 
65
    if (not *ptr)
89
66
    {
90
 
      unordered_map::size_type erased= cache.erase(identifier);
91
 
 
92
 
      if (erased)
 
67
      if (cache.erase(identifier))
93
68
        return true;
94
 
 
95
 
      assert(0); // This should be imposssible
 
69
      assert(false); // This should be imposssible
96
70
    }
97
71
    error= EE_OK;
98
72
  }
100
74
  {
101
75
    error= ER_CATALOG_DOES_NOT_EXIST;
102
76
  }
103
 
 
104
77
  return false;
105
78
}
106
79