db/mork/src/morkIntMap.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-  */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1999
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #ifndef _MDB_
  39 #include "mdb.h"
  40 #endif
  41
  42 #ifndef _MORK_
  43 #include "mork.h"
  44 #endif
  45
  46 #ifndef _MORKNODE_
  47 #include "morkNode.h"
  48 #endif
  49
  50 #ifndef _MORKENV_
  51 #include "morkEnv.h"
  52 #endif
  53
  54 #ifndef _MORKMAP_
  55 #include "morkMap.h"
  56 #endif
  57
  58 #ifndef _MORKINTMAP_
  59 #include "morkIntMap.h"
  60 #endif
  61
  62 //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
  63
  64 // ````` ````` ````` ````` `````
  65 // { ===== begin morkNode interface =====
  66
  67 /*public virtual*/ void
  68 morkIntMap::CloseMorkNode(morkEnv* ev) // CloseIntMap() only if open
  69 {
  70   if ( this->IsOpenNode() )
  71   {
  72     this->MarkClosing();
  73     this->CloseIntMap(ev);
  74     this->MarkShut();
  75   }
  76 }
  77
  78 /*public virtual*/
  79 morkIntMap::~morkIntMap() // assert CloseIntMap() executed earlier
  80 {
  81   MORK_ASSERT(this->IsShutNode());
  82 }
  83
  84 /*public non-poly*/
  85 morkIntMap::morkIntMap(morkEnv* ev,
  86   const morkUsage& inUsage, mork_size inValSize,
  87   nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap, mork_bool inHoldChanges)
  88 : morkMap(ev, inUsage, ioHeap, sizeof(mork_u4), inValSize,
  89   morkIntMap_kStartSlotCount, ioSlotHeap, inHoldChanges)
  90 {
  91   if ( ev->Good() )
  92     mNode_Derived = morkDerived_kIntMap;
  93 }
  94
  95 /*public non-poly*/ void
  96 morkIntMap::CloseIntMap(morkEnv* ev) // called by CloseMorkNode();
  97 {
  98   if ( this )
  99   {
 100     if ( this->IsNode() )
 101     {
 102       this->CloseMap(ev);
 103       this->MarkShut();
 104     }
 105     else
 106       this->NonNodeError(ev);
 107   }
 108   else
 109     ev->NilPointerError();
 110 }
 111
 112 // } ===== end morkNode methods =====
 113 // ````` ````` ````` ````` `````
 114
 115 // { ===== begin morkMap poly interface =====
 116 /*virtual*/ mork_bool // *((mork_u4*) inKeyA) == *((mork_u4*) inKeyB)
 117 morkIntMap::Equal(morkEnv* ev, const void* inKeyA, const void* inKeyB) const
 118 {
 119   MORK_USED_1(ev);
 120   return *((const mork_u4*) inKeyA) == *((const mork_u4*) inKeyB);
 121 }
 122
 123 /*virtual*/ mork_u4 // some integer function of *((mork_u4*) inKey)
 124 morkIntMap::Hash(morkEnv* ev, const void* inKey) const
 125 {
 126   MORK_USED_1(ev);
 127   return *((const mork_u4*) inKey);
 128 }
 129 // } ===== end morkMap poly interface =====
 130
 131 mork_bool
 132 morkIntMap::AddInt(morkEnv* ev, mork_u4 inKey, void* ioAddress)
 133   // the AddInt() method return value equals ev->Good().
 134 {
 135   if ( ev->Good() )
 136   {
 137     this->Put(ev, &inKey, &ioAddress,
 138       /*key*/ (void*) 0, /*val*/ (void*) 0, (mork_change**) 0);
 139   }
 140
 141   return ev->Good();
 142 }
 143
 144 mork_bool
 145 morkIntMap::CutInt(morkEnv* ev, mork_u4 inKey)
 146 {
 147   return this->Cut(ev, &inKey, /*key*/ (void*) 0, /*val*/ (void*) 0,
 148     (mork_change**) 0);
 149 }
 150
 151 void*
 152 morkIntMap::GetInt(morkEnv* ev, mork_u4 inKey)
 153   // Note the returned val does NOT have an increase in refcount for this.
 154 {
 155   void* val = 0; // old val in the map
 156   this->Get(ev, &inKey, /*key*/ (void*) 0, &val, (mork_change**) 0);
 157
 158   return val;
 159 }
 160
 161 mork_bool
 162 morkIntMap::HasInt(morkEnv* ev, mork_u4 inKey)
 163   // Note the returned val does NOT have an increase in refcount for this.
 164 {
 165   return this->Get(ev, &inKey, /*key*/ (void*) 0, /*val*/ (void*) 0,
 166     (mork_change**) 0);
 167 }
 168
 169 //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
 170
 171 #ifdef MORK_POINTER_MAP_IMPL
 172
 173 // ````` ````` ````` ````` `````
 174 // { ===== begin morkNode interface =====
 175
 176 /*public virtual*/ void
 177 morkPointerMap::CloseMorkNode(morkEnv* ev) // ClosePointerMap() only if open
 178 {
 179   if ( this->IsOpenNode() )
 180   {
 181     this->MarkClosing();
 182     this->ClosePointerMap(ev);
 183     this->MarkShut();
 184   }
 185 }
 186
 187 /*public virtual*/
 188 morkPointerMap::~morkPointerMap() // assert ClosePointerMap() executed earlier
 189 {
 190   MORK_ASSERT(this->IsShutNode());
 191 }
 192
 193 /*public non-poly*/
 194 morkPointerMap::morkPointerMap(morkEnv* ev,
 195   const morkUsage& inUsage, nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap)
 196 : morkMap(ev, inUsage, ioHeap, sizeof(void*), sizeof(void*),
 197   morkPointerMap_kStartSlotCount, ioSlotHeap,
 198   /*inHoldChanges*/ morkBool_kFalse)
 199 {
 200   if ( ev->Good() )
 201     mNode_Derived = morkDerived_kPointerMap;
 202 }
 203
 204 /*public non-poly*/ void
 205 morkPointerMap::ClosePointerMap(morkEnv* ev) // called by CloseMorkNode();
 206 {
 207   if ( this )
 208   {
 209     if ( this->IsNode() )
 210     {
 211       this->CloseMap(ev);
 212       this->MarkShut();
 213     }
 214     else
 215       this->NonNodeError(ev);
 216   }
 217   else
 218     ev->NilPointerError();
 219 }
 220
 221 // } ===== end morkNode methods =====
 222 // ````` ````` ````` ````` `````
 223
 224 // { ===== begin morkMap poly interface =====
 225 /*virtual*/ mork_bool // *((void**) inKeyA) == *((void**) inKeyB)
 226 morkPointerMap::Equal(morkEnv* ev, const void* inKeyA, const void* inKeyB) const
 227 {
 228   MORK_USED_1(ev);
 229   return *((const void**) inKeyA) == *((const void**) inKeyB);
 230 }
 231
 232 /*virtual*/ mork_u4 // some integer function of *((mork_u4*) inKey)
 233 morkPointerMap::Hash(morkEnv* ev, const void* inKey) const
 234 {
 235   MORK_USED_1(ev);
 236   return *((const mork_u4*) inKey);
 237 }
 238 // } ===== end morkMap poly interface =====
 239
 240 mork_bool
 241 morkPointerMap::AddPointer(morkEnv* ev, void* inKey, void* ioAddress)
 242   // the AddPointer() method return value equals ev->Good().
 243 {
 244   if ( ev->Good() )
 245   {
 246     this->Put(ev, &inKey, &ioAddress,
 247       /*key*/ (void*) 0, /*val*/ (void*) 0, (mork_change**) 0);
 248   }
 249
 250   return ev->Good();
 251 }
 252
 253 mork_bool
 254 morkPointerMap::CutPointer(morkEnv* ev, void* inKey)
 255 {
 256   return this->Cut(ev, &inKey, /*key*/ (void*) 0, /*val*/ (void*) 0,
 257     (mork_change**) 0);
 258 }
 259
 260 void*
 261 morkPointerMap::GetPointer(morkEnv* ev, void* inKey)
 262   // Note the returned val does NOT have an increase in refcount for this.
 263 {
 264   void* val = 0; // old val in the map
 265   this->Get(ev, &inKey, /*key*/ (void*) 0, &val, (mork_change**) 0);
 266
 267   return val;
 268 }
 269
 270 mork_bool
 271 morkPointerMap::HasPointer(morkEnv* ev, void* inKey)
 272   // Note the returned val does NOT have an increase in refcount for this.
 273 {
 274   return this->Get(ev, &inKey, /*key*/ (void*) 0, /*val*/ (void*) 0,
 275     (mork_change**) 0);
 276 }
 277 #endif /*MORK_POINTER_MAP_IMPL*/
 278
 279
 280 //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789