/* -*- 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

// 456789_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 searches.  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 than 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;
}

// 456789_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");
}

// 456789_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;
}

// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789