Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef _MDB_
# include "mdb.h"
#endif
#ifndef _MORK_
# include "mork.h"
#endif
#ifndef _MORKNODE_
# include "morkNode.h"
#endif
#ifndef _MORKENV_
# include "morkEnv.h"
#endif
#ifndef _MORKCURSOR_
# include "morkCursor.h"
#endif
#ifndef _MORKPORTTABLECURSOR_
# include "morkPortTableCursor.h"
#endif
#ifndef _MORKSTORE_
# include "morkStore.h"
#endif
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
// ````` ````` ````` ````` `````
// { ===== begin morkNode interface =====
/*public virtual*/ void morkPortTableCursor::CloseMorkNode(
morkEnv* ev) // ClosePortTableCursor() only if open
{
if (this->IsOpenNode()) {
this->MarkClosing();
this->ClosePortTableCursor(ev);
this->MarkShut();
}
}
/*public virtual*/
morkPortTableCursor::~morkPortTableCursor() // ClosePortTableCursor() executed
// earlier
{
CloseMorkNode(mMorkEnv);
}
/*public non-poly*/
morkPortTableCursor::morkPortTableCursor(morkEnv* ev, const morkUsage& inUsage,
nsIMdbHeap* ioHeap, morkStore* ioStore,
mdb_scope inRowScope,
mdb_kind inTableKind,
nsIMdbHeap* ioSlotHeap)
: morkCursor(ev, inUsage, ioHeap),
mPortTableCursor_Store(0),
mPortTableCursor_RowScope((mdb_scope)-1) // we want != inRowScope
,
mPortTableCursor_TableKind((mdb_kind)-1) // we want != inTableKind
,
mPortTableCursor_LastTable(0) // not refcounted
,
mPortTableCursor_RowSpace(0) // strong ref to row space
,
mPortTableCursor_TablesDidEnd(morkBool_kFalse),
mPortTableCursor_SpacesDidEnd(morkBool_kFalse) {
if (ev->Good()) {
if (ioStore && ioSlotHeap) {
mCursor_Pos = -1;
mCursor_Seed = 0; // let the iterator do its own seed handling
morkStore::SlotWeakStore(ioStore, ev, &mPortTableCursor_Store);
if (this->SetRowScope(ev, inRowScope))
this->SetTableKind(ev, inTableKind);
if (ev->Good()) mNode_Derived = morkDerived_kPortTableCursor;
} else
ev->NilPointerError();
}
}
NS_IMPL_ISUPPORTS_INHERITED(morkPortTableCursor, morkCursor,
nsIMdbPortTableCursor)
morkEnv* morkPortTableCursor::CanUsePortTableCursor(nsIMdbEnv* mev,
mork_bool inMutable,
nsresult* outErr) const {
morkEnv* outEnv = 0;
morkEnv* ev = morkEnv::FromMdbEnv(mev);
if (ev) {
if (IsPortTableCursor())
outEnv = ev;
else
NonPortTableCursorTypeError(ev);
*outErr = ev->AsErr();
}
MORK_ASSERT(outEnv);
return outEnv;
}
/*public non-poly*/ void morkPortTableCursor::ClosePortTableCursor(
morkEnv* ev) {
if (this->IsNode()) {
mCursor_Pos = -1;
mCursor_Seed = 0;
mPortTableCursor_LastTable = 0;
morkStore::SlotWeakStore((morkStore*)0, ev, &mPortTableCursor_Store);
morkRowSpace::SlotStrongRowSpace((morkRowSpace*)0, ev,
&mPortTableCursor_RowSpace);
this->CloseCursor(ev);
this->MarkShut();
} else
this->NonNodeError(ev);
}
// } ===== end morkNode methods =====
// ````` ````` ````` ````` `````
/*static*/ void morkPortTableCursor::NilCursorStoreError(morkEnv* ev) {
ev->NewError("nil mPortTableCursor_Store");
}
/*static*/ void morkPortTableCursor::NonPortTableCursorTypeError(morkEnv* ev) {
ev->NewError("non morkPortTableCursor");
}
mork_bool morkPortTableCursor::SetRowScope(morkEnv* ev, mork_scope inRowScope) {
mPortTableCursor_RowScope = inRowScope;
mPortTableCursor_LastTable = 0; // restart iteration of space
mPortTableCursor_TableIter.CloseMapIter(ev);
mPortTableCursor_TablesDidEnd = morkBool_kTrue;
mPortTableCursor_SpacesDidEnd = morkBool_kTrue;
morkStore* store = mPortTableCursor_Store;
if (store) {
morkRowSpace* space = mPortTableCursor_RowSpace;
if (inRowScope) // intend to cover a specific scope only?
{
space = store->LazyGetRowSpace(ev, inRowScope);
morkRowSpace::SlotStrongRowSpace(space, ev, &mPortTableCursor_RowSpace);
// We want mPortTableCursor_SpacesDidEnd == morkBool_kTrue
// to show this is the only space to be covered.
} else // prepare space map iter to cover all space scopes
{
morkRowSpaceMapIter* rsi = &mPortTableCursor_SpaceIter;
rsi->InitRowSpaceMapIter(ev, &store->mStore_RowSpaces);
space = 0;
(void)rsi->FirstRowSpace(ev, (mork_scope*)0, &space);
morkRowSpace::SlotStrongRowSpace(space, ev, &mPortTableCursor_RowSpace);
if (space) // found first space in store
mPortTableCursor_SpacesDidEnd = morkBool_kFalse;
}
this->init_space_tables_map(ev);
} else
this->NilCursorStoreError(ev);
return ev->Good();
}
void morkPortTableCursor::init_space_tables_map(morkEnv* ev) {
morkRowSpace* space = mPortTableCursor_RowSpace;
if (space && ev->Good()) {
morkTableMapIter* ti = &mPortTableCursor_TableIter;
ti->InitTableMapIter(ev, &space->mRowSpace_Tables);
if (ev->Good()) mPortTableCursor_TablesDidEnd = morkBool_kFalse;
}
}
mork_bool morkPortTableCursor::SetTableKind(morkEnv* ev,
mork_kind inTableKind) {
mPortTableCursor_TableKind = inTableKind;
mPortTableCursor_LastTable = 0; // restart iteration of space
mPortTableCursor_TablesDidEnd = morkBool_kTrue;
morkRowSpace* space = mPortTableCursor_RowSpace;
if (!space && mPortTableCursor_RowScope == 0) {
this->SetRowScope(ev, 0);
}
this->init_space_tables_map(ev);
return ev->Good();
}
morkRowSpace* morkPortTableCursor::NextSpace(morkEnv* ev) {
morkRowSpace* outSpace = 0;
mPortTableCursor_LastTable = 0;
mPortTableCursor_SpacesDidEnd = morkBool_kTrue;
mPortTableCursor_TablesDidEnd = morkBool_kTrue;
if (!mPortTableCursor_RowScope) // not just one scope?
{
morkStore* store = mPortTableCursor_Store;
if (store) {
morkRowSpaceMapIter* rsi = &mPortTableCursor_SpaceIter;
(void)rsi->NextRowSpace(ev, (mork_scope*)0, &outSpace);
morkRowSpace::SlotStrongRowSpace(outSpace, ev,
&mPortTableCursor_RowSpace);
if (outSpace) // found next space in store
{
mPortTableCursor_SpacesDidEnd = morkBool_kFalse;
this->init_space_tables_map(ev);
if (ev->Bad()) outSpace = 0;
}
} else
this->NilCursorStoreError(ev);
}
return outSpace;
}
morkTable* morkPortTableCursor::NextTable(morkEnv* ev) {
mork_kind kind = mPortTableCursor_TableKind;
do // until spaces end, or until we find a table in a space
{
morkRowSpace* space = mPortTableCursor_RowSpace;
if (mPortTableCursor_TablesDidEnd) // current space exhausted?
space = this->NextSpace(ev); // go on to the next space
if (space) // have a space remaining that might hold tables?
{
#ifdef MORK_BEAD_OVER_NODE_MAPS
morkTableMapIter* ti = &mPortTableCursor_TableIter;
morkTable* table =
(mPortTableCursor_LastTable) ? ti->NextTable(ev) : ti->FirstTable(ev);
for (; table && ev->Good(); table = ti->NextTable(ev))
#else /*MORK_BEAD_OVER_NODE_MAPS*/
mork_tid* key = 0; // ignore keys in table map
morkTable* table = 0; // old value table in the map
morkTableMapIter* ti = &mPortTableCursor_TableIter;
mork_change* c = (mPortTableCursor_LastTable)
? ti->NextTable(ev, key, &table)
: ti->FirstTable(ev, key, &table);
for (; c && ev->Good(); c = ti->NextTable(ev, key, &table))
#endif /*MORK_BEAD_OVER_NODE_MAPS*/
{
if (table && table->IsTable()) {
if (!kind || kind == table->mTable_Kind) {
mPortTableCursor_LastTable = table; // ti->NextTable() hence
return table;
}
} else
table->NonTableTypeWarning(ev);
}
mPortTableCursor_TablesDidEnd = morkBool_kTrue; // space is done
mPortTableCursor_LastTable = 0; // make sure next space starts fresh
}
} while (ev->Good() && !mPortTableCursor_SpacesDidEnd);
return (morkTable*)0;
}
// { ----- begin table iteration methods -----
// { ===== begin nsIMdbPortTableCursor methods =====
// { ----- begin attribute methods -----
NS_IMETHODIMP
morkPortTableCursor::SetPort(nsIMdbEnv* mev, nsIMdbPort* ioPort) {
NS_ASSERTION(false, "not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
morkPortTableCursor::GetPort(nsIMdbEnv* mev, nsIMdbPort** acqPort) {
nsresult outErr = NS_OK;
nsIMdbPort* outPort = 0;
morkEnv* ev =
this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
if (mPortTableCursor_Store)
outPort = mPortTableCursor_Store->AcquireStoreHandle(ev);
outErr = ev->AsErr();
}
if (acqPort) *acqPort = outPort;
return outErr;
}
NS_IMETHODIMP
morkPortTableCursor::SetRowScope(nsIMdbEnv* mev, // sets pos to -1
mdb_scope inRowScope) {
nsresult outErr = NS_OK;
morkEnv* ev =
this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
mCursor_Pos = -1;
SetRowScope(ev, inRowScope);
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkPortTableCursor::GetRowScope(nsIMdbEnv* mev, mdb_scope* outRowScope) {
nsresult outErr = NS_OK;
mdb_scope rowScope = 0;
morkEnv* ev =
this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
rowScope = mPortTableCursor_RowScope;
outErr = ev->AsErr();
}
*outRowScope = rowScope;
return outErr;
}
// setting row scope to zero iterates over all row scopes in port
NS_IMETHODIMP
morkPortTableCursor::SetTableKind(nsIMdbEnv* mev, // sets pos to -1
mdb_kind inTableKind) {
nsresult outErr = NS_OK;
morkEnv* ev =
this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
mCursor_Pos = -1;
SetTableKind(ev, inTableKind);
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkPortTableCursor::GetTableKind(nsIMdbEnv* mev, mdb_kind* outTableKind)
// setting table kind to zero iterates over all table kinds in row scope
{
nsresult outErr = NS_OK;
mdb_kind tableKind = 0;
morkEnv* ev =
this->CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
tableKind = mPortTableCursor_TableKind;
outErr = ev->AsErr();
}
*outTableKind = tableKind;
return outErr;
}
// } ----- end attribute methods -----
// { ----- begin table iteration methods -----
NS_IMETHODIMP
morkPortTableCursor::NextTable( // get table at next position in the db
nsIMdbEnv* mev, // context
nsIMdbTable** acqTable) {
nsresult outErr = NS_OK;
nsIMdbTable* outTable = 0;
morkEnv* ev =
CanUsePortTableCursor(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = NextTable(ev);
if (table && ev->Good()) outTable = table->AcquireTableHandle(ev);
outErr = ev->AsErr();
}
if (acqTable) *acqTable = outTable;
return outErr;
}
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789