db/mork/src/morkPortTableCursor.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 _MORKCURSOR_
  55 #include "morkCursor.h"
  56 #endif
  57
  58 #ifndef _MORKPORTTABLECURSOR_
  59 #include "morkPortTableCursor.h"
  60 #endif
  61
  62 #ifndef _MORKSTORE_
  63 #include "morkStore.h"
  64 #endif
  65
  66 //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
  67
  68 // ````` ````` ````` ````` `````
  69 // { ===== begin morkNode interface =====
  70
  71 /*public virtual*/ void
  72 morkPortTableCursor::CloseMorkNode(morkEnv* ev) // ClosePortTableCursor() only if open
  73 {
  74   if ( this->IsOpenNode() )
  75   {
  76     this->MarkClosing();
  77     this->ClosePortTableCursor(ev);
  78     this->MarkShut();
  79   }
  80 }
  81
  82 /*public virtual*/
  83 morkPortTableCursor::~morkPortTableCursor() // ClosePortTableCursor() executed earlier
  84 {
  85   CloseMorkNode(mMorkEnv);
  86 }
  87
  88 /*public non-poly*/
  89 morkPortTableCursor::morkPortTableCursor(morkEnv* ev,
  90   const morkUsage& inUsage,
  91   nsIMdbHeap* ioHeap, morkStore* ioStore, mdb_scope inRowScope,
  92   mdb_kind inTableKind, nsIMdbHeap* ioSlotHeap)
  93 : morkCursor(ev, inUsage, ioHeap)
  94 , mPortTableCursor_Store( 0 )
  95 , mPortTableCursor_RowScope( (mdb_scope) -1 ) // we want != inRowScope
  96 , mPortTableCursor_TableKind( (mdb_kind) -1 ) // we want != inTableKind
  97 , mPortTableCursor_LastTable ( 0 ) // not refcounted
  98 , mPortTableCursor_RowSpace( 0 ) // strong ref to row space
  99 , mPortTableCursor_TablesDidEnd( morkBool_kFalse )
 100 , mPortTableCursor_SpacesDidEnd( morkBool_kFalse )
 101 {
 102   if ( ev->Good() )
 103   {
 104     if ( ioStore && ioSlotHeap )
 105     {
 106       mCursor_Pos = -1;
 107       mCursor_Seed = 0; // let the iterator do it's own seed handling
 108       morkStore::SlotWeakStore(ioStore, ev, &mPortTableCursor_Store);
 109
 110       if ( this->SetRowScope(ev, inRowScope) )
 111         this->SetTableKind(ev, inTableKind);
 112
 113       if ( ev->Good() )
 114         mNode_Derived = morkDerived_kPortTableCursor;
 115     }
 116     else
 117       ev->NilPointerError();
 118   }
 119 }
 120
 121 NS_IMPL_ISUPPORTS_INHERITED1(morkPortTableCursor, morkCursor, nsIMdbPortTableCursor)
 122
 123 morkEnv*
 124 morkPortTableCursor::CanUsePortTableCursor(nsIMdbEnv* mev,
 125   mork_bool inMutable, mdb_err* outErr) const
 126 {
 127   morkEnv* outEnv = 0;
 128   morkEnv* ev = morkEnv::FromMdbEnv(mev);
 129   if ( ev )
 130   {
 131     if ( IsPortTableCursor() )
 132       outEnv = ev;
 133     else
 134       NonPortTableCursorTypeError(ev);
 135     *outErr = ev->AsErr();
 136   }
 137   MORK_ASSERT(outEnv);
 138   return outEnv;
 139 }
 140
 141
 142 /*public non-poly*/ void
 143 morkPortTableCursor::ClosePortTableCursor(morkEnv* ev)
 144 {
 145   if ( this )
 146   {
 147     if ( this->IsNode() )
 148     {
 149       mCursor_Pos = -1;
 150       mCursor_Seed = 0;
 151       mPortTableCursor_LastTable = 0;
 152       morkStore::SlotWeakStore((morkStore*) 0, ev, &mPortTableCursor_Store);
 153       morkRowSpace::SlotStrongRowSpace((morkRowSpace*) 0, ev,
 154         &mPortTableCursor_RowSpace);
 155       this->CloseCursor(ev);
 156       this->MarkShut();
 157     }
 158     else
 159       this->NonNodeError(ev);
 160   }
 161   else
 162     ev->NilPointerError();
 163 }
 164
 165 // } ===== end morkNode methods =====
 166 // ````` ````` ````` ````` `````
 167
 168 /*static*/ void
 169 morkPortTableCursor::NilCursorStoreError(morkEnv* ev)
 170 {
 171   ev->NewError("nil mPortTableCursor_Store");
 172 }
 173
 174 /*static*/ void
 175 morkPortTableCursor::NonPortTableCursorTypeError(morkEnv* ev)
 176 {
 177   ev->NewError("non morkPortTableCursor");
 178 }
 179
 180 mork_bool
 181 morkPortTableCursor::SetRowScope(morkEnv* ev, mork_scope inRowScope)
 182 {
 183   mPortTableCursor_RowScope = inRowScope;
 184   mPortTableCursor_LastTable = 0; // restart iteration of space
 185
 186   mPortTableCursor_TableIter.CloseMapIter(ev);
 187   mPortTableCursor_TablesDidEnd = morkBool_kTrue;
 188   mPortTableCursor_SpacesDidEnd = morkBool_kTrue;
 189
 190   morkStore* store = mPortTableCursor_Store;
 191   if ( store )
 192   {
 193     morkRowSpace* space = mPortTableCursor_RowSpace;
 194
 195     if ( inRowScope ) // intend to cover a specific scope only?
 196     {
 197       space = store->LazyGetRowSpace(ev, inRowScope);
 198       morkRowSpace::SlotStrongRowSpace(space, ev,
 199        &mPortTableCursor_RowSpace);
 200
 201       // We want mPortTableCursor_SpacesDidEnd == morkBool_kTrue
 202       // to show this is the only space to be covered.
 203     }
 204     else // prepare space map iter to cover all space scopes
 205     {
 206       morkRowSpaceMapIter* rsi = &mPortTableCursor_SpaceIter;
 207       rsi->InitRowSpaceMapIter(ev, &store->mStore_RowSpaces);
 208
 209       space = 0;
 210       (void) rsi->FirstRowSpace(ev, (mork_scope*) 0, &space);
 211       morkRowSpace::SlotStrongRowSpace(space, ev,
 212         &mPortTableCursor_RowSpace);
 213
 214       if ( space ) // found first space in store
 215         mPortTableCursor_SpacesDidEnd = morkBool_kFalse;
 216     }
 217
 218     this->init_space_tables_map(ev);
 219   }
 220   else
 221     this->NilCursorStoreError(ev);
 222
 223   return ev->Good();
 224 }
 225
 226 void
 227 morkPortTableCursor::init_space_tables_map(morkEnv* ev)
 228 {
 229   morkRowSpace* space = mPortTableCursor_RowSpace;
 230   if ( space && ev->Good() )
 231   {
 232     morkTableMapIter* ti = &mPortTableCursor_TableIter;
 233     ti->InitTableMapIter(ev, &space->mRowSpace_Tables);
 234     if ( ev->Good() )
 235       mPortTableCursor_TablesDidEnd = morkBool_kFalse;
 236   }
 237 }
 238
 239
 240 mork_bool
 241 morkPortTableCursor::SetTableKind(morkEnv* ev, mork_kind inTableKind)
 242 {
 243   mPortTableCursor_TableKind = inTableKind;
 244   mPortTableCursor_LastTable = 0; // restart iteration of space
 245
 246   mPortTableCursor_TablesDidEnd = morkBool_kTrue;
 247
 248   morkRowSpace* space = mPortTableCursor_RowSpace;
 249   if ( !space && mPortTableCursor_RowScope == 0 )
 250   {
 251     this->SetRowScope(ev, 0);
 252     space = mPortTableCursor_RowSpace;
 253   }
 254   this->init_space_tables_map(ev);
 255
 256   return ev->Good();
 257 }
 258
 259 morkRowSpace*
 260 morkPortTableCursor::NextSpace(morkEnv* ev)
 261 {
 262   morkRowSpace* outSpace = 0;
 263   mPortTableCursor_LastTable = 0;
 264   mPortTableCursor_SpacesDidEnd = morkBool_kTrue;
 265   mPortTableCursor_TablesDidEnd = morkBool_kTrue;
 266
 267   if ( !mPortTableCursor_RowScope ) // not just one scope?
 268   {
 269     morkStore* store = mPortTableCursor_Store;
 270     if ( store )
 271     {
 272       morkRowSpaceMapIter* rsi = &mPortTableCursor_SpaceIter;
 273
 274       (void) rsi->NextRowSpace(ev, (mork_scope*) 0, &outSpace);
 275       morkRowSpace::SlotStrongRowSpace(outSpace, ev,
 276         &mPortTableCursor_RowSpace);
 277
 278       if ( outSpace ) // found next space in store
 279       {
 280         mPortTableCursor_SpacesDidEnd = morkBool_kFalse;
 281
 282         this->init_space_tables_map(ev);
 283
 284         if ( ev->Bad() )
 285           outSpace = 0;
 286       }
 287     }
 288     else
 289       this->NilCursorStoreError(ev);
 290   }
 291
 292   return outSpace;
 293 }
 294
 295 morkTable *
 296 morkPortTableCursor::NextTable(morkEnv* ev)
 297 {
 298   mork_kind kind = mPortTableCursor_TableKind;
 299
 300   do // until spaces end, or until we find a table in a space
 301   {
 302     morkRowSpace* space = mPortTableCursor_RowSpace;
 303     if ( mPortTableCursor_TablesDidEnd ) // current space exhausted?
 304       space = this->NextSpace(ev); // go on to the next space
 305
 306     if ( space ) // have a space remaining that might hold tables?
 307     {
 308 #ifdef MORK_BEAD_OVER_NODE_MAPS
 309       morkTableMapIter* ti = &mPortTableCursor_TableIter;
 310       morkTable* table = ( mPortTableCursor_LastTable )?
 311         ti->NextTable(ev) : ti->FirstTable(ev);
 312
 313       for ( ; table && ev->Good(); table = ti->NextTable(ev) )
 314
 315 #else /*MORK_BEAD_OVER_NODE_MAPS*/
 316       mork_tid* key = 0; // ignore keys in table map
 317       morkTable* table = 0; // old value table in the map
 318       morkTableMapIter* ti = &mPortTableCursor_TableIter;
 319       mork_change* c = ( mPortTableCursor_LastTable )?
 320         ti->NextTable(ev, key, &table) : ti->FirstTable(ev, key, &table);
 321
 322       for ( ; c && ev->Good(); c = ti->NextTable(ev, key, &table) )
 323 #endif /*MORK_BEAD_OVER_NODE_MAPS*/
 324       {
 325         if ( table && table->IsTable() )
 326         {
 327           if ( !kind || kind == table->mTable_Kind )
 328           {
 329             mPortTableCursor_LastTable = table; // ti->NextTable() hence
 330             return table;
 331           }
 332         }
 333         else
 334           table->NonTableTypeWarning(ev);
 335       }
 336       mPortTableCursor_TablesDidEnd = morkBool_kTrue; // space is done
 337       mPortTableCursor_LastTable = 0; // make sure next space starts fresh
 338     }
 339
 340   } while ( ev->Good() && !mPortTableCursor_SpacesDidEnd );
 341
 342   return (morkTable*) 0;
 343 }
 344
 345
 346 // { ----- begin table iteration methods -----
 347
 348 // { ===== begin nsIMdbPortTableCursor methods =====
 349
 350 // { ----- begin attribute methods -----
 351 NS_IMETHODIMP
 352 morkPortTableCursor::SetPort(nsIMdbEnv* mev, nsIMdbPort* ioPort)
 353 {
 354   NS_ASSERTION(PR_FALSE,"not implemented");
 355   return NS_ERROR_NOT_IMPLEMENTED;
 356 }
 357
 358 NS_IMETHODIMP
 359 morkPortTableCursor::GetPort(nsIMdbEnv* mev, nsIMdbPort** acqPort)
 360 {
 361   mdb_err outErr = 0;
 362   nsIMdbPort* outPort = 0;
 363   morkEnv* ev =
 364     this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 365   if ( ev )
 366   {
 367     if ( mPortTableCursor_Store )
 368       outPort = mPortTableCursor_Store->AcquireStoreHandle(ev);
 369     outErr = ev->AsErr();
 370   }
 371   if ( acqPort )
 372     *acqPort = outPort;
 373   return outErr;
 374 }
 375
 376 NS_IMETHODIMP
 377 morkPortTableCursor::SetRowScope(nsIMdbEnv* mev, // sets pos to -1
 378   mdb_scope inRowScope)
 379 {
 380   mdb_err outErr = 0;
 381   morkEnv* ev =
 382     this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 383   if ( ev )
 384   {
 385     mCursor_Pos = -1;
 386
 387     SetRowScope(ev, inRowScope);
 388     outErr = ev->AsErr();
 389   }
 390   return outErr;
 391 }
 392
 393 NS_IMETHODIMP
 394 morkPortTableCursor::GetRowScope(nsIMdbEnv* mev, mdb_scope* outRowScope)
 395 {
 396   mdb_err outErr = 0;
 397   mdb_scope rowScope = 0;
 398   morkEnv* ev =
 399     this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 400   if ( ev )
 401   {
 402     rowScope = mPortTableCursor_RowScope;
 403     outErr = ev->AsErr();
 404   }
 405   *outRowScope = rowScope;
 406   return outErr;
 407 }
 408 // setting row scope to zero iterates over all row scopes in port
 409
 410 NS_IMETHODIMP
 411 morkPortTableCursor::SetTableKind(nsIMdbEnv* mev, // sets pos to -1
 412   mdb_kind inTableKind)
 413 {
 414   mdb_err outErr = 0;
 415   morkEnv* ev =
 416     this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 417   if ( ev )
 418   {
 419     mCursor_Pos = -1;
 420
 421     SetTableKind(ev, inTableKind);
 422     outErr = ev->AsErr();
 423   }
 424   return outErr;
 425 }
 426
 427 NS_IMETHODIMP
 428 morkPortTableCursor::GetTableKind(nsIMdbEnv* mev, mdb_kind* outTableKind)
 429 // setting table kind to zero iterates over all table kinds in row scope
 430 {
 431   mdb_err outErr = 0;
 432   mdb_kind tableKind = 0;
 433   morkEnv* ev =
 434     this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 435   if ( ev )
 436   {
 437     tableKind = mPortTableCursor_TableKind;
 438     outErr = ev->AsErr();
 439   }
 440   *outTableKind = tableKind;
 441   return outErr;
 442 }
 443 // } ----- end attribute methods -----
 444
 445 // { ----- begin table iteration methods -----
 446 NS_IMETHODIMP
 447 morkPortTableCursor::NextTable( // get table at next position in the db
 448   nsIMdbEnv* mev, // context
 449   nsIMdbTable** acqTable)
 450 {
 451   mdb_err outErr = 0;
 452   nsIMdbTable* outTable = 0;
 453   morkEnv* ev =
 454     CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
 455   if ( ev )
 456   {
 457     morkTable* table = NextTable(ev);
 458     if ( table && ev->Good() )
 459       outTable = table->AcquireTableHandle(ev);
 460
 461     outErr = ev->AsErr();
 462   }
 463   if ( acqTable )
 464     *acqTable = outTable;
 465   return outErr;
 466 }
 467
 468 //3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789