Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

1 files changed, 1610 insertions, 0 deletions

diff --git a/db/mork/src/morkTable.cpp b/db/mork/src/morkTable.cpp
new file mode 100644
index 000000000..aaa4bd50e
--- /dev/null
+++ b/db/mork/src/morkTable.cpp
@@ -0,0 +1,1610 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-  */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MDB_
+#include "mdb.h"
+#endif
+
+#ifndef _MORK_
+#include "mork.h"
+#endif
+
+#ifndef _MORKNODE_
+#include "morkNode.h"
+#endif
+
+#ifndef _MORKMAP_
+#include "morkMap.h"
+#endif
+
+#ifndef _MORKENV_
+#include "morkEnv.h"
+#endif
+
+#ifndef _MORKTABLE_
+#include "morkTable.h"
+#endif
+
+#ifndef _MORKSTORE_
+#include "morkStore.h"
+#endif
+
+#ifndef _MORKROWSPACE_
+#include "morkRowSpace.h"
+#endif
+
+#ifndef _MORKARRAY_
+#include "morkArray.h"
+#endif
+
+#ifndef _MORKROW_
+#include "morkRow.h"
+#endif
+
+#ifndef _MORKTABLEROWCURSOR_
+#include "morkTableRowCursor.h"
+#endif
+
+#ifndef _MORKROWOBJECT_
+#include "morkRowObject.h"
+#endif
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+// ````` ````` ````` ````` ````` 
+// { ===== begin morkNode interface =====
+
+/*public virtual*/ void
+morkTable::CloseMorkNode(morkEnv* ev) /*i*/ // CloseTable() only if open
+{
+  if ( this->IsOpenNode() )
+  {
+    morkObject::CloseMorkNode(ev); // give base class a chance.
+    this->MarkClosing();
+    this->CloseTable(ev);
+    this->MarkShut();
+  }
+}
+
+/*public virtual*/
+morkTable::~morkTable() /*i*/ // assert CloseTable() executed earlier
+{
+  CloseMorkNode(mMorkEnv);
+  MORK_ASSERT(this->IsShutNode());
+  MORK_ASSERT(mTable_Store==0);
+  MORK_ASSERT(mTable_RowSpace==0);
+}
+
+/*public non-poly*/
+morkTable::morkTable(morkEnv* ev, /*i*/
+  const morkUsage& inUsage, nsIMdbHeap* ioHeap, 
+  morkStore* ioStore, nsIMdbHeap* ioSlotHeap, morkRowSpace* ioRowSpace,
+  const mdbOid* inOptionalMetaRowOid, // can be nil to avoid specifying 
+  mork_tid inTid, mork_kind inKind, mork_bool inMustBeUnique)
+: morkObject(ev, inUsage, ioHeap, (mork_color) inTid, (morkHandle*) 0)
+, mTable_Store( 0 )
+, mTable_RowSpace( 0 )
+, mTable_MetaRow( 0 )
+
+, mTable_RowMap( 0 )
+// , mTable_RowMap(ev, morkUsage::kMember, (nsIMdbHeap*) 0, ioSlotHeap,
+//   morkTable_kStartRowMapSlotCount)
+, mTable_RowArray(ev, morkUsage::kMember, (nsIMdbHeap*) 0,
+  morkTable_kStartRowArraySize, ioSlotHeap)
+  
+, mTable_ChangeList()
+, mTable_ChangesCount( 0 )
+, mTable_ChangesMax( 3 ) // any very small number greater than zero
+
+, mTable_Kind( inKind )
+
+, mTable_Flags( 0 )
+, mTable_Priority( morkPriority_kLo ) // NOT high priority
+, mTable_GcUses( 0 )
+, mTable_Pad( 0 )
+{
+  this->mLink_Next = 0;
+  this->mLink_Prev = 0;
+  
+  if ( ev->Good() )
+  {
+    if ( ioStore && ioSlotHeap && ioRowSpace )
+    {
+      if ( inKind )
+      {
+        if ( inMustBeUnique )
+          this->SetTableUnique();
+        mTable_Store = ioStore;
+        mTable_RowSpace = ioRowSpace;
+        if ( inOptionalMetaRowOid )
+          mTable_MetaRowOid = *inOptionalMetaRowOid;
+        else
+        {
+          mTable_MetaRowOid.mOid_Scope = 0;
+          mTable_MetaRowOid.mOid_Id = morkRow_kMinusOneRid;
+        }
+        if ( ev->Good() )
+        {
+          if ( this->MaybeDirtySpaceStoreAndTable() )
+            this->SetTableRewrite(); // everything is dirty
+            
+          mNode_Derived = morkDerived_kTable;
+        }
+        this->MaybeDirtySpaceStoreAndTable(); // new table might dirty store
+      }
+      else
+        ioRowSpace->ZeroKindError(ev);
+    }
+    else
+      ev->NilPointerError();
+  }
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(morkTable, morkObject, nsIMdbTable)
+
+/*public non-poly*/ void
+morkTable::CloseTable(morkEnv* ev) /*i*/ // called by CloseMorkNode();
+{
+    if ( this->IsNode() )
+    {
+      morkRowMap::SlotStrongRowMap((morkRowMap*) 0, ev, &mTable_RowMap);
+      // mTable_RowMap.CloseMorkNode(ev);
+      mTable_RowArray.CloseMorkNode(ev);
+      mTable_Store = 0;
+      mTable_RowSpace = 0;
+      this->MarkShut();
+    }
+    else
+      this->NonNodeError(ev);
+}
+
+
+// } ===== end morkNode methods =====
+// ````` ````` ````` ````` ````` 
+
+// { ===== begin nsIMdbCollection methods =====
+
+// { ----- begin attribute methods -----
+NS_IMETHODIMP
+morkTable::GetSeed(nsIMdbEnv* mev,
+  mdb_seed* outSeed)    // member change count
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    *outSeed = mTable_RowArray.mArray_Seed;
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+  
+NS_IMETHODIMP
+morkTable::GetCount(nsIMdbEnv* mev,
+  mdb_count* outCount) // member count
+{
+  NS_ENSURE_ARG_POINTER(outCount);
+  *outCount = mTable_RowArray.mArray_Fill;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::GetPort(nsIMdbEnv* mev,
+  nsIMdbPort** acqPort) // collection container
+{
+  (void) morkEnv::FromMdbEnv(mev);
+  NS_ENSURE_ARG_POINTER(acqPort);    
+  *acqPort = mTable_Store;
+  return NS_OK;
+}
+// } ----- end attribute methods -----
+
+// { ----- begin cursor methods -----
+NS_IMETHODIMP
+morkTable::GetCursor( // make a cursor starting iter at inMemberPos
+  nsIMdbEnv* mev, // context
+  mdb_pos inMemberPos, // zero-based ordinal pos of member in collection
+  nsIMdbCursor** acqCursor) // acquire new cursor instance
+{
+  return this->GetTableRowCursor(mev, inMemberPos,
+    (nsIMdbTableRowCursor**) acqCursor);
+}
+// } ----- end cursor methods -----
+
+// { ----- begin ID methods -----
+NS_IMETHODIMP
+morkTable::GetOid(nsIMdbEnv* mev,
+  mdbOid* outOid) // read object identity
+{
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  GetTableOid(ev, outOid);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::BecomeContent(nsIMdbEnv* mev,
+  const mdbOid* inOid) // exchange content
+{
+  NS_ASSERTION(false, "not implemented"); 
+  return NS_ERROR_NOT_IMPLEMENTED;
+  // remember table->MaybeDirtySpaceStoreAndTable();
+}
+
+// } ----- end ID methods -----
+
+// { ----- begin activity dropping methods -----
+NS_IMETHODIMP
+morkTable::DropActivity( // tell collection usage no longer expected
+  nsIMdbEnv* mev)
+{
+  NS_ASSERTION(false, "not implemented"); 
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// } ----- end activity dropping methods -----
+
+// } ===== end nsIMdbCollection methods =====
+
+// { ===== begin nsIMdbTable methods =====
+
+// { ----- begin attribute methods -----
+
+NS_IMETHODIMP
+morkTable::SetTablePriority(nsIMdbEnv* mev, mdb_priority inPrio)
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( inPrio > morkPriority_kMax )
+      inPrio = morkPriority_kMax;
+      
+    mTable_Priority = inPrio;
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::GetTablePriority(nsIMdbEnv* mev, mdb_priority* outPrio)
+{
+  nsresult outErr = NS_OK;
+  mork_priority prio = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    prio = mTable_Priority;
+    if ( prio > morkPriority_kMax )
+    {
+      prio = morkPriority_kMax;
+      mTable_Priority = prio;
+    }
+    outErr = ev->AsErr();
+  }
+  if ( outPrio )
+    *outPrio = prio;
+  return outErr;
+}
+
+
+NS_IMETHODIMP
+morkTable:: GetTableBeVerbose(nsIMdbEnv* mev, mdb_bool* outBeVerbose)
+{
+  NS_ENSURE_ARG_POINTER(outBeVerbose);
+  *outBeVerbose = IsTableVerbose();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::SetTableBeVerbose(nsIMdbEnv* mev, mdb_bool inBeVerbose)
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( inBeVerbose )
+      SetTableVerbose();
+    else
+      ClearTableVerbose();
+   
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::GetTableIsUnique(nsIMdbEnv* mev, mdb_bool* outIsUnique)
+{
+  NS_ENSURE_ARG_POINTER(outIsUnique);
+  *outIsUnique = IsTableUnique();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::GetTableKind(nsIMdbEnv* mev, mdb_kind* outTableKind)
+{
+  NS_ENSURE_ARG_POINTER(outTableKind);
+  *outTableKind = mTable_Kind;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::GetRowScope(nsIMdbEnv* mev, mdb_scope* outRowScope)
+{
+  nsresult outErr = NS_OK;
+  mdb_scope rowScope = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( mTable_RowSpace )
+      rowScope = mTable_RowSpace->SpaceScope();
+    else
+      NilRowSpaceError(ev);
+
+    outErr = ev->AsErr();
+  }
+  if ( outRowScope )
+    *outRowScope = rowScope;
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::GetMetaRow( nsIMdbEnv* mev,
+  const mdbOid* inOptionalMetaRowOid, // can be nil to avoid specifying 
+  mdbOid* outOid, // output meta row oid, can be nil to suppress output
+  nsIMdbRow** acqRow) // acquire table's unique singleton meta row
+  // The purpose of a meta row is to support the persistent recording of
+  // meta info about a table as cells put into the distinguished meta row.
+  // Each table has exactly one meta row, which is not considered a member
+  // of the collection of rows inside the table.  The only way to tell
+  // whether a row is a meta row is by the fact that it is returned by this
+  // GetMetaRow() method from some table. Otherwise nothing distinguishes
+  // a meta row from any other row.  A meta row can be used anyplace that
+  // any other row can be used, and can even be put into other tables (or
+  // the same table) as a table member, if this is useful for some reason.
+  // The first attempt to access a table's meta row using GetMetaRow() will
+  // cause the meta row to be created if it did not already exist.  When the
+  // meta row is created, it will have the row oid that was previously
+  // requested for this table's meta row; or if no oid was ever explicitly
+  // specified for this meta row, then a unique oid will be generated in
+  // the row scope named "metaScope" (so obviously MDB clients should not
+  // manually allocate any row IDs from that special meta scope namespace).
+  // The meta row oid can be specified either when the table is created, or
+  // else the first time that GetMetaRow() is called, by passing a non-nil
+  // pointer to an oid for parameter inOptionalMetaRowOid.  The meta row's
+  // actual oid is returned in outOid (if this is a non-nil pointer), and
+  // it will be different from inOptionalMetaRowOid when the meta row was
+  // already given a different oid earlier.
+{
+  nsresult outErr = NS_OK;
+  nsIMdbRow* outRow = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRow* row = GetMetaRow(ev, inOptionalMetaRowOid);
+    if ( row && ev->Good() )
+    {
+      if ( outOid )
+        *outOid = row->mRow_Oid;
+        
+      outRow = row->AcquireRowHandle(ev, mTable_Store);
+    }
+    outErr = ev->AsErr();
+  }
+  if ( acqRow )
+    *acqRow = outRow;
+    
+  if ( ev->Bad() && outOid )
+  {
+    outOid->mOid_Scope = 0;
+    outOid->mOid_Id = morkRow_kMinusOneRid;
+  }
+  return outErr;
+}
+
+// } ----- end attribute methods -----
+
+// { ----- begin cursor methods -----
+NS_IMETHODIMP
+morkTable::GetTableRowCursor( // make a cursor, starting iteration at inRowPos
+  nsIMdbEnv* mev, // context
+  mdb_pos inRowPos, // zero-based ordinal position of row in table
+  nsIMdbTableRowCursor** acqCursor) // acquire new cursor instance
+{
+  nsresult outErr = NS_OK;
+  nsIMdbTableRowCursor* outCursor = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkTableRowCursor* cursor = NewTableRowCursor(ev, inRowPos);
+    if ( cursor )
+    {
+      if ( ev->Good() )
+      {
+        // cursor->mCursor_Seed = (mork_seed) inRowPos;
+        outCursor = cursor;
+        outCursor->AddRef();
+      }
+    }
+      
+    outErr = ev->AsErr();
+  }
+  if ( acqCursor )
+    *acqCursor = outCursor;
+  return outErr;
+}
+// } ----- end row position methods -----
+
+// { ----- begin row position methods -----
+NS_IMETHODIMP
+morkTable::PosToOid( // get row member for a table position
+  nsIMdbEnv* mev, // context
+  mdb_pos inRowPos, // zero-based ordinal position of row in table
+  mdbOid* outOid) // row oid at the specified position
+{
+  nsresult outErr = NS_OK;
+  mdbOid roid;
+  roid.mOid_Scope = 0;
+  roid.mOid_Id = (mork_id) -1;
+  
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRow* row = SafeRowAt(ev, inRowPos);
+    if ( row )
+      roid = row->mRow_Oid;
+    
+    outErr = ev->AsErr();
+  }
+  if ( outOid )
+    *outOid = roid;
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::OidToPos( // test for the table position of a row member
+  nsIMdbEnv* mev, // context
+  const mdbOid* inOid, // row to find in table
+  mdb_pos* outPos) // zero-based ordinal position of row in table
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    mork_pos pos = ArrayHasOid(ev, inOid);
+    if ( outPos )
+      *outPos = pos;
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::PosToRow( // get row member for a table position
+  nsIMdbEnv* mev, // context
+  mdb_pos inRowPos, // zero-based ordinal position of row in table
+  nsIMdbRow** acqRow) // acquire row at table position inRowPos
+{
+  nsresult outErr = NS_OK;
+  nsIMdbRow* outRow = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRow* row = SafeRowAt(ev, inRowPos);
+    if ( row && mTable_Store )
+      outRow = row->AcquireRowHandle(ev, mTable_Store);
+      
+    outErr = ev->AsErr();
+  }
+  if ( acqRow )
+    *acqRow = outRow;
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::RowToPos( // test for the table position of a row member
+  nsIMdbEnv* mev, // context
+  nsIMdbRow* ioRow, // row to find in table
+  mdb_pos* outPos) // zero-based ordinal position of row in table
+{
+  nsresult outErr = NS_OK;
+  mork_pos pos = -1;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRowObject* row = (morkRowObject*) ioRow;
+    pos = ArrayHasOid(ev, &row->mRowObject_Row->mRow_Oid);
+    outErr = ev->AsErr();
+  }
+  if ( outPos )
+    *outPos = pos;
+  return outErr;
+}
+  
+// Note that HasRow() performs the inverse oid->pos mapping
+// } ----- end row position methods -----
+
+// { ----- begin oid set methods -----
+NS_IMETHODIMP
+morkTable::AddOid( // make sure the row with inOid is a table member 
+  nsIMdbEnv* mev, // context
+  const mdbOid* inOid) // row to ensure membership in table
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::HasOid( // test for the table position of a row member
+  nsIMdbEnv* mev, // context
+  const mdbOid* inOid, // row to find in table
+  mdb_bool* outHasOid) // whether inOid is a member row
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( outHasOid )
+      *outHasOid = MapHasOid(ev, inOid);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::CutOid( // make sure the row with inOid is not a member 
+  nsIMdbEnv* mev, // context
+  const mdbOid* inOid) // row to remove from table
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( inOid && mTable_Store )
+    {
+      morkRow* row = mTable_Store->GetRow(ev, inOid);
+      if ( row )
+        CutRow(ev, row);
+    }
+    else
+      ev->NilPointerError();
+      
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+// } ----- end oid set methods -----
+
+// { ----- begin row set methods -----
+NS_IMETHODIMP
+morkTable::NewRow( // create a new row instance in table
+  nsIMdbEnv* mev, // context
+  mdbOid* ioOid, // please use zero (unbound) rowId for db-assigned IDs
+  nsIMdbRow** acqRow) // create new row
+{
+  nsresult outErr = NS_OK;
+  nsIMdbRow* outRow = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( ioOid && mTable_Store )
+    {
+      morkRow* row = 0;
+      if ( ioOid->mOid_Id == morkRow_kMinusOneRid )
+        row = mTable_Store->NewRow(ev, ioOid->mOid_Scope);
+      else
+        row = mTable_Store->NewRowWithOid(ev, ioOid);
+        
+      if ( row && AddRow(ev, row) )
+        outRow = row->AcquireRowHandle(ev, mTable_Store);
+    }
+    else
+      ev->NilPointerError();
+      
+    outErr = ev->AsErr();
+  }
+  if ( acqRow )
+    *acqRow = outRow;
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::AddRow( // make sure the row with inOid is a table member 
+  nsIMdbEnv* mev, // context
+  nsIMdbRow* ioRow) // row to ensure membership in table
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRowObject *rowObj = (morkRowObject *) ioRow;
+    morkRow* row = rowObj->mRowObject_Row;
+    AddRow(ev, row);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::HasRow( // test for the table position of a row member
+  nsIMdbEnv* mev, // context
+  nsIMdbRow* ioRow, // row to find in table
+  mdb_bool* outBool) // zero-based ordinal position of row in table
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRowObject *rowObj = (morkRowObject *) ioRow;
+    morkRow* row = rowObj->mRowObject_Row;
+    if ( outBool )
+      *outBool = MapHasOid(ev, &row->mRow_Oid);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+
+NS_IMETHODIMP
+morkTable::CutRow( // make sure the row with inOid is not a member 
+  nsIMdbEnv* mev, // context
+  nsIMdbRow* ioRow) // row to remove from table
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRowObject *rowObj = (morkRowObject *) ioRow;
+    morkRow* row = rowObj->mRowObject_Row;
+    CutRow(ev, row);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::CutAllRows( // remove all rows from the table 
+  nsIMdbEnv* mev) // context
+{
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    CutAllRows(ev);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+// } ----- end row set methods -----
+
+// { ----- begin searching methods -----
+NS_IMETHODIMP
+morkTable::FindRowMatches( // search variable number of sorted cols
+  nsIMdbEnv* mev, // context
+  const mdbYarn* inPrefix, // content to find as prefix in row's column cell
+  nsIMdbTableRowCursor** acqCursor) // set of matching rows
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+  
+NS_IMETHODIMP
+morkTable::GetSearchColumns( // query columns used by FindRowMatches()
+  nsIMdbEnv* mev, // context
+  mdb_count* outCount, // context
+  mdbColumnSet* outColSet) // caller supplied space to put columns
+  // GetSearchColumns() returns the columns actually searched when the
+  // FindRowMatches() method is called.  No more than mColumnSet_Count
+  // slots of mColumnSet_Columns will be written, since mColumnSet_Count
+  // indicates how many slots are present in the column array.  The
+  // actual number of search column used by the table is returned in
+  // the outCount parameter; if this number exceeds mColumnSet_Count,
+  // then a caller needs a bigger array to read the entire column set.
+  // The minimum of mColumnSet_Count and outCount is the number slots
+  // in mColumnSet_Columns that were actually written by this method.
+  //
+  // Callers are expected to change this set of columns by calls to
+  // nsIMdbTable::SearchColumnsHint() or SetSearchSorting(), or both.
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+// } ----- end searching methods -----
+
+// { ----- begin hinting methods -----
+NS_IMETHODIMP
+morkTable::SearchColumnsHint( // advise re future expected search cols  
+  nsIMdbEnv* mev, // context
+  const mdbColumnSet* inColumnSet) // columns likely to be searched
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+  
+NS_IMETHODIMP
+morkTable::SortColumnsHint( // advise re future expected sort columns  
+  nsIMdbEnv* mev, // context
+  const mdbColumnSet* inColumnSet) // columns for likely sort requests
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::StartBatchChangeHint( // advise before many adds and cuts  
+  nsIMdbEnv* mev, // context
+  const void* inLabel) // intend unique address to match end call
+  // If batch starts nest by virtue of nesting calls in the stack, then
+  // the address of a local variable makes a good batch start label that
+  // can be used at batch end time, and such addresses remain unique.
+{
+  // we don't do anything here.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+morkTable::EndBatchChangeHint( // advise before many adds and cuts  
+  nsIMdbEnv* mev, // context
+  const void* inLabel) // label matching start label
+  // Suppose a table is maintaining one or many sort orders for a table,
+  // so that every row added to the table must be inserted in each sort,
+  // and every row cut must be removed from each sort.  If a db client
+  // intends to make many such changes before needing any information
+  // about the order or positions of rows inside a table, then a client
+  // might tell the table to start batch changes in order to disable
+  // sorting of rows for the interim.  Presumably a table will then do
+  // a full sort of all rows at need when the batch changes end, or when
+  // a surprise request occurs for row position during batch changes.
+{
+  // we don't do anything here.
+  return NS_OK;
+}
+// } ----- end hinting methods -----
+
+// { ----- begin sorting methods -----
+// sorting: note all rows are assumed sorted by row ID as a secondary
+// sort following the primary column sort, when table rows are sorted.
+
+NS_IMETHODIMP
+morkTable::CanSortColumn( // query which column is currently used for sorting
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // column to query sorting potential
+  mdb_bool* outCanSort) // whether the column can be sorted
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::GetSorting( // view same table in particular sorting
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // requested new column for sorting table
+  nsIMdbSorting** acqSorting) // acquire sorting for column
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::SetSearchSorting( // use this sorting in FindRowMatches()
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // often same as nsIMdbSorting::GetSortColumn()
+  nsIMdbSorting* ioSorting) // requested sorting for some column
+  // SetSearchSorting() attempts to inform the table that ioSorting
+  // should be used during calls to FindRowMatches() for searching
+  // the column which is actually sorted by ioSorting.  This method
+  // is most useful in conjunction with nsIMdbSorting::SetCompare(),
+  // because otherwise a caller would not be able to override the
+  // comparison ordering method used during searchs.  Note that some
+  // database implementations might be unable to use an arbitrarily
+  // specified sort order, either due to schema or runtime interface
+  // constraints, in which case ioSorting might not actually be used.
+  // Presumably ioSorting is an instance that was returned from some
+  // earlier call to nsIMdbTable::GetSorting().  A caller can also
+  // use nsIMdbTable::SearchColumnsHint() to specify desired change
+  // in which columns are sorted and searched by FindRowMatches().
+  //
+  // A caller can pass a nil pointer for ioSorting to request that
+  // column inColumn no longer be used at all by FindRowMatches().
+  // But when ioSorting is non-nil, then inColumn should match the
+  // column actually sorted by ioSorting; when these do not agree,
+  // implementations are instructed to give precedence to the column
+  // specified by ioSorting (so this means callers might just pass
+  // zero for inColumn when ioSorting is also provided, since then
+  // inColumn is both redundant and ignored).
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// } ----- end sorting methods -----
+
+// { ----- begin moving methods -----
+// moving a row does nothing unless a table is currently unsorted
+
+NS_IMETHODIMP
+morkTable::MoveOid( // change position of row in unsorted table
+  nsIMdbEnv* mev, // context
+  const mdbOid* inOid,  // row oid to find in table
+  mdb_pos inHintFromPos, // suggested hint regarding start position
+  mdb_pos inToPos,       // desired new position for row inOid
+  mdb_pos* outActualPos) // actual new position of row in table
+{
+  nsresult outErr = NS_OK;
+  mdb_pos actualPos = -1; // meaning it was never found in table
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    if ( inOid && mTable_Store )
+    {
+      morkRow* row = mTable_Store->GetRow(ev, inOid);
+      if ( row )
+        actualPos = MoveRow(ev, row, inHintFromPos, inToPos);
+    }
+    else
+      ev->NilPointerError();
+
+    outErr = ev->AsErr();
+  }
+  if ( outActualPos )
+    *outActualPos = actualPos;
+  return outErr;
+}
+
+NS_IMETHODIMP
+morkTable::MoveRow( // change position of row in unsorted table
+  nsIMdbEnv* mev, // context
+  nsIMdbRow* ioRow,  // row oid to find in table
+  mdb_pos inHintFromPos, // suggested hint regarding start position
+  mdb_pos inToPos,       // desired new position for row ioRow
+  mdb_pos* outActualPos) // actual new position of row in table
+{
+  mdb_pos actualPos = -1; // meaning it was never found in table
+  nsresult outErr = NS_OK;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if ( ev )
+  {
+    morkRowObject *rowObj = (morkRowObject *) ioRow;
+    morkRow* row = rowObj->mRowObject_Row;
+    actualPos = MoveRow(ev, row, inHintFromPos, inToPos);
+    outErr = ev->AsErr();
+  }
+  if ( outActualPos )
+    *outActualPos = actualPos;
+  return outErr;
+}
+// } ----- end moving methods -----
+
+// { ----- begin index methods -----
+NS_IMETHODIMP
+morkTable::AddIndex( // create a sorting index for column if possible
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // the column to sort by index
+  nsIMdbThumb** acqThumb) // acquire thumb for incremental index building
+// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
+// then the index addition will be finished.
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::CutIndex( // stop supporting a specific column index
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // the column with index to be removed
+  nsIMdbThumb** acqThumb) // acquire thumb for incremental index destroy
+// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
+// then the index removal will be finished.
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::HasIndex( // query for current presence of a column index
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // the column to investigate
+  mdb_bool* outHasIndex) // whether column has index for this column
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::EnableIndexOnSort( // create an index for col on first sort
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn) // the column to index if ever sorted
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::QueryIndexOnSort( // check whether index on sort is enabled
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn, // the column to investigate
+  mdb_bool* outIndexOnSort) // whether column has index-on-sort enabled
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkTable::DisableIndexOnSort( // prevent future index creation on sort
+  nsIMdbEnv* mev, // context
+  mdb_column inColumn) // the column to index if ever sorted
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+// } ----- end index methods -----
+
+// } ===== end nsIMdbTable methods =====
+
+// we override these so that we'll use the xpcom add and release ref.
+#ifndef _MSC_VER
+mork_refs
+morkTable::AddStrongRef(nsIMdbEnv *ev)
+{
+  return (mork_refs) AddRef();
+}
+#endif
+
+mork_refs
+morkTable::AddStrongRef(morkEnv *ev)
+{
+  return (mork_refs) AddRef();
+}
+
+#ifndef _MSC_VER
+nsresult
+morkTable::CutStrongRef(nsIMdbEnv *ev)
+{
+  return (nsresult) Release();
+}
+#endif
+
+mork_refs
+morkTable::CutStrongRef(morkEnv *ev)
+{
+  return (mork_refs) Release();
+}
+
+mork_u2
+morkTable::AddTableGcUse(morkEnv* ev)
+{
+  MORK_USED_1(ev); 
+  if ( mTable_GcUses < morkTable_kMaxTableGcUses ) // not already maxed out?
+    ++mTable_GcUses;
+    
+  return mTable_GcUses;
+}
+
+mork_u2
+morkTable::CutTableGcUse(morkEnv* ev)
+{
+  if ( mTable_GcUses ) // any outstanding uses to cut?
+  {
+    if ( mTable_GcUses < morkTable_kMaxTableGcUses ) // not frozen at max?
+      --mTable_GcUses;
+  }
+  else
+    this->TableGcUsesUnderflowWarning(ev);
+    
+  return mTable_GcUses;
+}
+
+// table dirty handling more complex thatn morkNode::SetNodeDirty() etc.
+
+void morkTable::SetTableClean(morkEnv* ev)
+{
+  if ( mTable_ChangeList.HasListMembers() )
+  {
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    mTable_ChangeList.CutAndZapAllListMembers(ev, heap); // forget changes
+  }
+  mTable_ChangesCount = 0;
+  
+  mTable_Flags = 0;
+  this->SetNodeClean();
+}
+
+// notifications regarding table changes:
+
+void morkTable::NoteTableMoveRow(morkEnv* ev, morkRow* ioRow, mork_pos inPos)
+{
+  nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+  if ( this->IsTableRewrite() || this->HasChangeOverflow() )
+    this->NoteTableSetAll(ev);
+  else
+  {
+    morkTableChange* tableChange = new(*heap, ev)
+      morkTableChange(ev, ioRow, inPos);
+    if ( tableChange )
+    {
+      if ( ev->Good() )
+      {
+        mTable_ChangeList.PushTail(tableChange);
+        ++mTable_ChangesCount;
+      }
+      else
+      {
+        tableChange->ZapOldNext(ev, heap);
+        this->SetTableRewrite(); // just plan to write all table rows
+      }
+    }
+  }
+}
+
+void morkTable::note_row_move(morkEnv* ev, morkRow* ioRow, mork_pos inNewPos)
+{
+  if ( this->IsTableRewrite() || this->HasChangeOverflow() )
+    this->NoteTableSetAll(ev);
+  else
+  {
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    morkTableChange* tableChange = new(*heap, ev)
+      morkTableChange(ev, ioRow, inNewPos);
+    if ( tableChange )
+    {
+      if ( ev->Good() )
+      {
+        mTable_ChangeList.PushTail(tableChange);
+        ++mTable_ChangesCount;
+      }
+      else
+      {
+        tableChange->ZapOldNext(ev, heap);
+        this->NoteTableSetAll(ev);
+      }
+    }
+  }
+}
+
+void morkTable::note_row_change(morkEnv* ev, mork_change inChange,
+  morkRow* ioRow)
+{
+  if ( this->IsTableRewrite() || this->HasChangeOverflow() )
+    this->NoteTableSetAll(ev);
+  else
+  {
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    morkTableChange* tableChange = new(*heap, ev)
+      morkTableChange(ev, inChange, ioRow);
+    if ( tableChange )
+    {
+      if ( ev->Good() )
+      {
+        mTable_ChangeList.PushTail(tableChange);
+        ++mTable_ChangesCount;
+      }
+      else
+      {
+        tableChange->ZapOldNext(ev, heap);
+        this->NoteTableSetAll(ev);
+      }
+    }
+  }
+}
+
+void morkTable::NoteTableSetAll(morkEnv* ev)
+{
+  if ( mTable_ChangeList.HasListMembers() )
+  {
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    mTable_ChangeList.CutAndZapAllListMembers(ev, heap); // forget changes
+  }
+  mTable_ChangesCount = 0;
+  this->SetTableRewrite();
+}
+
+/*static*/ void
+morkTable::TableGcUsesUnderflowWarning(morkEnv* ev)
+{
+  ev->NewWarning("mTable_GcUses underflow");
+}
+
+/*static*/ void
+morkTable::NonTableTypeError(morkEnv* ev)
+{
+  ev->NewError("non morkTable");
+}
+
+/*static*/ void
+morkTable::NonTableTypeWarning(morkEnv* ev)
+{
+  ev->NewWarning("non morkTable");
+}
+
+/*static*/ void
+morkTable::NilRowSpaceError(morkEnv* ev)
+{
+  ev->NewError("nil mTable_RowSpace");
+}
+
+mork_bool morkTable::MaybeDirtySpaceStoreAndTable()
+{
+  morkRowSpace* rowSpace = mTable_RowSpace;
+  if ( rowSpace )
+  {
+    morkStore* store = rowSpace->mSpace_Store;
+    if ( store && store->mStore_CanDirty )
+    {
+      store->SetStoreDirty();
+      rowSpace->mSpace_CanDirty = morkBool_kTrue;
+    }
+    
+    if ( rowSpace->mSpace_CanDirty ) // first time being dirtied?
+    {
+      if ( this->IsTableClean() )
+      {
+        mork_count rowCount = this->GetRowCount();
+        mork_count oneThird = rowCount / 4; // one third of rows
+        if ( oneThird > 0x07FFF ) // more than half max u2?
+          oneThird = 0x07FFF;
+          
+        mTable_ChangesMax = (mork_u2) oneThird;
+      }
+      this->SetTableDirty();
+      rowSpace->SetRowSpaceDirty();
+      
+      return morkBool_kTrue;
+    }
+  }
+  return morkBool_kFalse;
+}
+
+morkRow*
+morkTable::GetMetaRow(morkEnv* ev, const mdbOid* inOptionalMetaRowOid)
+{
+  morkRow* outRow = mTable_MetaRow;
+  if ( !outRow )
+  {
+    morkStore* store = mTable_Store;
+    mdbOid* oid = &mTable_MetaRowOid;
+    if ( inOptionalMetaRowOid && !oid->mOid_Scope )
+      *oid = *inOptionalMetaRowOid;
+      
+    if ( oid->mOid_Scope ) // oid already recorded in table?
+      outRow = store->OidToRow(ev, oid);
+    else
+    {
+      outRow = store->NewRow(ev, morkStore_kMetaScope);
+      if ( outRow ) // need to record new oid in table?
+        *oid = outRow->mRow_Oid;
+    }
+    mTable_MetaRow = outRow;
+    if ( outRow ) // need to note another use of this row?
+    {
+      outRow->AddRowGcUse(ev);
+
+      this->SetTableNewMeta();
+      if ( this->IsTableClean() ) // catch dirty status of meta row?
+        this->MaybeDirtySpaceStoreAndTable();
+    }
+  }
+  
+  return outRow;
+}
+
+void
+morkTable::GetTableOid(morkEnv* ev, mdbOid* outOid)
+{
+  morkRowSpace* space = mTable_RowSpace;
+  if ( space )
+  {
+    outOid->mOid_Scope = space->SpaceScope();
+    outOid->mOid_Id = this->TableId();
+  }
+  else
+    this->NilRowSpaceError(ev);
+}
+
+nsIMdbTable*
+morkTable::AcquireTableHandle(morkEnv* ev)
+{
+  AddRef();
+  return this;
+}
+
+mork_pos
+morkTable::ArrayHasOid(morkEnv* ev, const mdbOid* inOid)
+{
+  MORK_USED_1(ev); 
+  mork_count count = mTable_RowArray.mArray_Fill;
+  mork_pos pos = -1;
+  while ( ++pos < (mork_pos)count )
+  {
+    morkRow* row = (morkRow*) mTable_RowArray.At(pos);
+    MORK_ASSERT(row);
+    if ( row && row->EqualOid(inOid) )
+    {
+      return pos;
+    }
+  }
+  return -1;
+}
+
+mork_bool
+morkTable::MapHasOid(morkEnv* ev, const mdbOid* inOid)
+{
+  if ( mTable_RowMap )
+    return ( mTable_RowMap->GetOid(ev, inOid) != 0 );
+  else
+    return ( ArrayHasOid(ev, inOid) >= 0 );
+}
+
+void morkTable::build_row_map(morkEnv* ev)
+{
+  morkRowMap* map = mTable_RowMap;
+  if ( !map )
+  {
+    mork_count count = mTable_RowArray.mArray_Fill + 3;
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    map = new(*heap, ev) morkRowMap(ev, morkUsage::kHeap, heap, heap, count);
+    if ( map )
+    {
+      if ( ev->Good() )
+      {
+        mTable_RowMap = map; // put strong ref here
+        count = mTable_RowArray.mArray_Fill;
+        mork_pos pos = -1;
+        while ( ++pos < (mork_pos)count )
+        {
+          morkRow* row = (morkRow*) mTable_RowArray.At(pos);
+          if ( row && row->IsRow() )
+            map->AddRow(ev, row);
+          else
+            row->NonRowTypeError(ev);
+        }
+      }
+      else
+        map->CutStrongRef(ev);
+    }
+  }
+}
+
+morkRow* morkTable::find_member_row(morkEnv* ev, morkRow* ioRow)
+{
+  if ( mTable_RowMap )
+    return mTable_RowMap->GetRow(ev, ioRow);
+  else
+  {
+    mork_count count = mTable_RowArray.mArray_Fill;
+    mork_pos pos = -1;
+    while ( ++pos < (mork_pos)count )
+    {
+      morkRow* row = (morkRow*) mTable_RowArray.At(pos);
+      if ( row == ioRow )
+        return row;
+    }
+  }
+  return (morkRow*) 0;
+}
+
+mork_pos
+morkTable::MoveRow(morkEnv* ev, morkRow* ioRow, // change row position
+  mork_pos inHintFromPos, // suggested hint regarding start position
+  mork_pos inToPos) // desired new position for row ioRow
+  // MoveRow() returns the actual position of ioRow afterwards; this
+  // position is -1 if and only if ioRow was not found as a member.     
+{
+  mork_pos outPos = -1; // means ioRow was not a table member
+  mork_bool canDirty = ( this->IsTableClean() )?
+    this->MaybeDirtySpaceStoreAndTable() : morkBool_kTrue;
+  
+  morkRow** rows = (morkRow**) mTable_RowArray.mArray_Slots;
+  mork_count count = mTable_RowArray.mArray_Fill;
+  if ( count && rows && ev->Good() ) // any members at all? no errors?
+  {
+    mork_pos lastPos = count - 1; // index of last row slot
+      
+    if ( inToPos > lastPos ) // beyond last used array slot?
+      inToPos = lastPos; // put row into last available slot
+    else if ( inToPos < 0 ) // before first usable slot?
+      inToPos = 0; // put row in very first slow
+      
+    if ( inHintFromPos > lastPos ) // beyond last used array slot?
+      inHintFromPos = lastPos; // seek row in last available slot
+    else if ( inHintFromPos < 0 ) // before first usable slot?
+      inHintFromPos = 0; // seek row in very first slow
+
+    morkRow** fromSlot = 0; // becomes nonzero of ioRow is ever found
+    morkRow** rowsEnd = rows + count; // one past last used array slot
+    
+    if ( inHintFromPos <= 0 ) // start of table? just scan for row?
+    {
+      morkRow** cursor = rows - 1; // before first array slot
+      while ( ++cursor < rowsEnd )
+      {
+        if ( *cursor == ioRow )
+        {
+          fromSlot = cursor;
+          break; // end while loop
+        }
+      }
+    }
+    else // search near the start position and work outwards
+    {
+      morkRow** lo = rows + inHintFromPos; // lowest search point
+      morkRow** hi = lo; // highest search point starts at lowest point
+      
+      // Seek ioRow in spiral widening search below and above inHintFromPos.
+      // This is faster when inHintFromPos is at all accurate, but is slower
+      // than a straightforward scan when inHintFromPos is nearly random.
+      
+      while ( lo >= rows || hi < rowsEnd ) // keep searching?
+      {
+        if ( lo >= rows ) // low direction search still feasible?
+        {
+          if ( *lo == ioRow ) // actually found the row?
+          {
+            fromSlot = lo;
+            break; // end while loop
+          }
+          --lo; // advance further lower
+        }
+        if ( hi < rowsEnd ) // high direction search still feasible?
+        {
+          if ( *hi == ioRow ) // actually found the row?
+          {
+            fromSlot = hi;
+            break; // end while loop
+          }
+          ++hi; // advance further higher
+        }
+      }
+    }
+    
+    if ( fromSlot ) // ioRow was found as a table member?
+    {
+      outPos = fromSlot - rows; // actual position where row was found
+      if ( outPos != inToPos ) // actually need to move this row?
+      {
+        morkRow** toSlot = rows + inToPos; // slot where row must go
+        
+        ++mTable_RowArray.mArray_Seed; // we modify the array now:
+        
+        if ( fromSlot < toSlot ) // row is moving upwards?
+        {
+          morkRow** up = fromSlot; // leading pointer going upward
+          while ( ++up <= toSlot ) // have not gone above destination?
+          {
+            *fromSlot = *up; // shift down one
+            fromSlot = up; // shift trailing pointer up
+          }
+        }
+        else // ( fromSlot > toSlot ) // row is moving downwards
+        {
+          morkRow** down = fromSlot; // leading pointer going downward
+          while ( --down >= toSlot ) // have not gone below destination?
+          {
+            *fromSlot = *down; // shift up one
+            fromSlot = down; // shift trailing pointer
+          }
+        }
+        *toSlot = ioRow;
+        outPos = inToPos; // okay, we actually moved the row here
+
+        if ( canDirty )
+          this->note_row_move(ev, ioRow, inToPos);
+      }
+    }
+  }
+  return outPos;
+}
+
+mork_bool
+morkTable::AddRow(morkEnv* ev, morkRow* ioRow)
+{
+  morkRow* row = this->find_member_row(ev, ioRow);
+  if ( !row && ev->Good() )
+  {
+    mork_bool canDirty = ( this->IsTableClean() )?
+      this->MaybeDirtySpaceStoreAndTable() : morkBool_kTrue;
+      
+    mork_pos pos = mTable_RowArray.AppendSlot(ev, ioRow);
+    if ( ev->Good() && pos >= 0 )
+    {
+      ioRow->AddRowGcUse(ev);
+      if ( mTable_RowMap )
+      {
+        if ( mTable_RowMap->AddRow(ev, ioRow) )
+        {
+          // okay, anything else?
+        }
+        else
+          mTable_RowArray.CutSlot(ev, pos);
+      }
+      else if ( mTable_RowArray.mArray_Fill >= morkTable_kMakeRowMapThreshold )
+        this->build_row_map(ev);
+
+      if ( canDirty && ev->Good() )
+        this->NoteTableAddRow(ev, ioRow);
+    }
+  }
+  return ev->Good();
+}
+
+mork_bool
+morkTable::CutRow(morkEnv* ev, morkRow* ioRow)
+{
+  morkRow* row = this->find_member_row(ev, ioRow);
+  if ( row )
+  {
+    mork_bool canDirty = ( this->IsTableClean() )?
+      this->MaybeDirtySpaceStoreAndTable() : morkBool_kTrue;
+      
+    mork_count count = mTable_RowArray.mArray_Fill;
+    morkRow** rowSlots = (morkRow**) mTable_RowArray.mArray_Slots;
+    if ( rowSlots ) // array has vector as expected?
+    {
+      mork_pos pos = -1;
+      morkRow** end = rowSlots + count;
+      morkRow** slot = rowSlots - 1; // prepare for preincrement:
+      while ( ++slot < end ) // another slot to check?
+      {
+        if ( *slot == row ) // found the slot containing row?
+        {
+          pos = slot - rowSlots; // record absolute position
+          break; // end while loop
+        }
+      }
+      if ( pos >= 0 ) // need to cut if from the array?
+        mTable_RowArray.CutSlot(ev, pos);
+      else
+        ev->NewWarning("row not found in array");
+    }
+    else
+      mTable_RowArray.NilSlotsAddressError(ev);
+      
+    if ( mTable_RowMap )
+      mTable_RowMap->CutRow(ev, ioRow);
+
+    if ( canDirty )
+      this->NoteTableCutRow(ev, ioRow);
+
+    if ( ioRow->CutRowGcUse(ev) == 0 )
+      ioRow->OnZeroRowGcUse(ev);
+  }
+  return ev->Good();
+}
+
+
+mork_bool
+morkTable::CutAllRows(morkEnv* ev)
+{
+  if ( this->MaybeDirtySpaceStoreAndTable() )
+  {
+    this->SetTableRewrite(); // everything is dirty
+    this->NoteTableSetAll(ev);
+  }
+    
+  if ( ev->Good() )
+  {
+    mTable_RowArray.CutAllSlots(ev);
+    if ( mTable_RowMap )
+    {
+      morkRowMapIter i(ev, mTable_RowMap);
+      mork_change* c = 0;
+      morkRow* r = 0;
+      
+      for ( c = i.FirstRow(ev, &r); c;  c = i.NextRow(ev, &r) )
+      {
+        if ( r )
+        {
+          if ( r->CutRowGcUse(ev) == 0 )
+            r->OnZeroRowGcUse(ev);
+            
+          i.CutHereRow(ev, (morkRow**) 0);
+        }
+        else
+          ev->NewWarning("nil row in table map");
+      }
+    }
+  }
+  return ev->Good();
+}
+
+morkTableRowCursor*
+morkTable::NewTableRowCursor(morkEnv* ev, mork_pos inRowPos)
+{
+  morkTableRowCursor* outCursor = 0;
+  if ( ev->Good() )
+  {
+    nsIMdbHeap* heap = mTable_Store->mPort_Heap;
+    morkTableRowCursor* cursor = new(*heap, ev)
+      morkTableRowCursor(ev, morkUsage::kHeap, heap, this, inRowPos);
+    if ( cursor )
+    {
+      if ( ev->Good() )
+        outCursor = cursor;
+      else
+        cursor->CutStrongRef((nsIMdbEnv *) ev);
+    }
+  }
+  return outCursor;
+}
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+morkTableChange::morkTableChange(morkEnv* ev, mork_change inChange,
+  morkRow* ioRow)
+// use this constructor for inChange == morkChange_kAdd or morkChange_kCut
+: morkNext()
+, mTableChange_Row( ioRow )
+, mTableChange_Pos( morkTableChange_kNone )
+{
+  if ( ioRow )
+  {
+    if ( ioRow->IsRow() )
+    {
+      if ( inChange == morkChange_kAdd )
+        mTableChange_Pos = morkTableChange_kAdd;
+      else if ( inChange == morkChange_kCut )
+        mTableChange_Pos = morkTableChange_kCut;
+      else
+        this->UnknownChangeError(ev);
+    }
+    else
+      ioRow->NonRowTypeError(ev);
+  }
+  else
+    ev->NilPointerError();
+}
+
+morkTableChange::morkTableChange(morkEnv* ev, morkRow* ioRow, mork_pos inPos)
+// use this constructor when the row is moved
+: morkNext()
+, mTableChange_Row( ioRow )
+, mTableChange_Pos( inPos )
+{
+  if ( ioRow )
+  {
+    if ( ioRow->IsRow() )
+    {
+      if ( inPos < 0 )
+        this->NegativeMovePosError(ev);
+    }
+    else
+      ioRow->NonRowTypeError(ev);
+  }
+  else
+    ev->NilPointerError();
+}
+
+void morkTableChange::UnknownChangeError(morkEnv* ev) const
+// morkChange_kAdd or morkChange_kCut
+{
+  ev->NewError("mTableChange_Pos neither kAdd nor kCut");
+}
+
+void morkTableChange::NegativeMovePosError(morkEnv* ev) const
+// move must be non-neg position
+{
+  ev->NewError("negative mTableChange_Pos for row move");
+}
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+
+morkTableMap::~morkTableMap()
+{
+}
+
+morkTableMap::morkTableMap(morkEnv* ev, const morkUsage& inUsage,
+  nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap)
+#ifdef MORK_BEAD_OVER_NODE_MAPS
+  : morkBeadMap(ev, inUsage, ioHeap, ioSlotHeap)
+#else /*MORK_BEAD_OVER_NODE_MAPS*/
+  : morkNodeMap(ev, inUsage, ioHeap, ioSlotHeap)
+#endif /*MORK_BEAD_OVER_NODE_MAPS*/
+{
+  if ( ev->Good() )
+    mNode_Derived = morkDerived_kTableMap;
+}
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+