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 _MORKBLOB_
# include "morkBlob.h"
#endif
#ifndef _MORKMAP_
# include "morkMap.h"
#endif
#ifndef _MORKENV_
# include "morkEnv.h"
#endif
#ifndef _MORKSTORE_
# include "morkStore.h"
#endif
#ifndef _MORKFACTORY_
# include "morkFactory.h"
#endif
#ifndef _MORKNODEMAP_
# include "morkNodeMap.h"
#endif
#ifndef _MORKROW_
# include "morkRow.h"
#endif
#ifndef _MORKTHUMB_
# include "morkThumb.h"
#endif
// #ifndef _MORKFILE_
// #include "morkFile.h"
// #endif
#ifndef _MORKBUILDER_
# include "morkBuilder.h"
#endif
#ifndef _MORKATOMSPACE_
# include "morkAtomSpace.h"
#endif
#ifndef _MORKSTREAM_
# include "morkStream.h"
#endif
#ifndef _MORKATOMSPACE_
# include "morkAtomSpace.h"
#endif
#ifndef _MORKROWSPACE_
# include "morkRowSpace.h"
#endif
#ifndef _MORKPORTTABLECURSOR_
# include "morkPortTableCursor.h"
#endif
#ifndef _MORKTABLE_
# include "morkTable.h"
#endif
#ifndef _MORKROWMAP_
# include "morkRowMap.h"
#endif
#ifndef _MORKPARSER_
# include "morkParser.h"
#endif
#include "nsCOMPtr.h"
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
// ````` ````` ````` ````` `````
// { ===== begin morkNode interface =====
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
// ````` ````` ````` ````` `````
// { ===== begin morkNode interface =====
/*public virtual*/ void morkStore::CloseMorkNode(
morkEnv* ev) // ClosePort() only if open
{
if (this->IsOpenNode()) {
this->MarkClosing();
this->CloseStore(ev);
this->MarkShut();
}
}
/*public non-poly*/ void morkStore::ClosePort(
morkEnv* ev) // called by CloseMorkNode();
{
if (this->IsNode()) {
morkFactory::SlotWeakFactory((morkFactory*)0, ev, &mPort_Factory);
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*)0, ev, &mPort_Heap);
this->CloseObject(ev);
this->MarkShut();
} else
this->NonNodeError(ev);
}
/*public virtual*/
morkStore::~morkStore() // assert CloseStore() executed earlier
{
if (IsOpenNode()) CloseMorkNode(mMorkEnv);
MORK_ASSERT(this->IsShutNode());
MORK_ASSERT(mStore_File == 0);
MORK_ASSERT(mStore_InStream == 0);
MORK_ASSERT(mStore_OutStream == 0);
MORK_ASSERT(mStore_Builder == 0);
MORK_ASSERT(mStore_OidAtomSpace == 0);
MORK_ASSERT(mStore_GroundAtomSpace == 0);
MORK_ASSERT(mStore_GroundColumnSpace == 0);
MORK_ASSERT(mStore_RowSpaces.IsShutNode());
MORK_ASSERT(mStore_AtomSpaces.IsShutNode());
MORK_ASSERT(mStore_Pool.IsShutNode());
}
/*public non-poly*/
morkStore::morkStore(
morkEnv* ev, const morkUsage& inUsage,
nsIMdbHeap* ioNodeHeap, // the heap (if any) for this node instance
morkFactory* inFactory, // the factory for this
nsIMdbHeap* ioPortHeap // the heap to hold all content in the port
)
: morkObject(ev, inUsage, ioNodeHeap, morkColor_kNone, (morkHandle*)0),
mPort_Env(ev),
mPort_Factory(0),
mPort_Heap(0),
mStore_OidAtomSpace(0),
mStore_GroundAtomSpace(0),
mStore_GroundColumnSpace(0)
,
mStore_File(0),
mStore_InStream(0),
mStore_Builder(0),
mStore_OutStream(0)
,
mStore_RowSpaces(ev, morkUsage::kMember, (nsIMdbHeap*)0, ioPortHeap),
mStore_AtomSpaces(ev, morkUsage::kMember, (nsIMdbHeap*)0, ioPortHeap),
mStore_Zone(ev, morkUsage::kMember, (nsIMdbHeap*)0, ioPortHeap),
mStore_Pool(ev, morkUsage::kMember, (nsIMdbHeap*)0, ioPortHeap)
,
mStore_CommitGroupIdentity(0)
,
mStore_FirstCommitGroupPos(0),
mStore_SecondCommitGroupPos(0)
// disable auto-assignment of atom IDs until someone knows it is okay:
,
mStore_CanAutoAssignAtomIdentity(morkBool_kFalse),
mStore_CanDirty(morkBool_kFalse) // not until the store is open
,
mStore_CanWriteIncremental(morkBool_kTrue) // always with few exceptions
{
if (ev->Good()) {
if (inFactory && ioPortHeap) {
morkFactory::SlotWeakFactory(inFactory, ev, &mPort_Factory);
nsIMdbHeap_SlotStrongHeap(ioPortHeap, ev, &mPort_Heap);
if (ev->Good()) mNode_Derived = morkDerived_kPort;
} else
ev->NilPointerError();
}
if (ev->Good()) {
mNode_Derived = morkDerived_kStore;
}
}
NS_IMPL_ISUPPORTS_INHERITED(morkStore, morkObject, nsIMdbStore)
/*public non-poly*/ void morkStore::CloseStore(
morkEnv* ev) // called by CloseMorkNode();
{
if (this->IsNode()) {
nsIMdbFile* file = mStore_File;
file->AddRef();
morkFactory::SlotWeakFactory((morkFactory*)0, ev, &mPort_Factory);
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*)0, ev, &mPort_Heap);
morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
&mStore_OidAtomSpace);
morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
&mStore_GroundAtomSpace);
morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
&mStore_GroundColumnSpace);
mStore_RowSpaces.CloseMorkNode(ev);
mStore_AtomSpaces.CloseMorkNode(ev);
morkBuilder::SlotStrongBuilder((morkBuilder*)0, ev, &mStore_Builder);
nsIMdbFile_SlotStrongFile((nsIMdbFile*)0, ev, &mStore_File);
file->Release();
morkStream::SlotStrongStream((morkStream*)0, ev, &mStore_InStream);
morkStream::SlotStrongStream((morkStream*)0, ev, &mStore_OutStream);
mStore_Pool.CloseMorkNode(ev);
mStore_Zone.CloseMorkNode(ev);
this->ClosePort(ev);
this->MarkShut();
} else
this->NonNodeError(ev);
}
// } ===== end morkNode methods =====
// ````` ````` ````` ````` `````
mork_bool morkStore::DoPreferLargeOverCompressCommit(morkEnv* ev)
// true when mStore_CanWriteIncremental && store has file large enough
{
nsIMdbFile* file = mStore_File;
if (file && mStore_CanWriteIncremental) {
mdb_pos fileEof = 0;
file->Eof(ev->AsMdbEnv(), &fileEof);
if (ev->Good() && fileEof > 128) return morkBool_kTrue;
}
return morkBool_kFalse;
}
mork_percent morkStore::PercentOfStoreWasted(morkEnv* ev) {
mork_percent outPercent = 0;
nsIMdbFile* file = mStore_File;
if (file) {
mork_pos firstPos = mStore_FirstCommitGroupPos;
mork_pos secondPos = mStore_SecondCommitGroupPos;
if (firstPos || secondPos) {
if (firstPos < 512 && secondPos > firstPos)
firstPos = secondPos; // better approximation of first commit
mork_pos fileLength = 0;
file->Eof(ev->AsMdbEnv(), &fileLength); // end of file
if (ev->Good() && fileLength > firstPos) {
mork_size groupContent = fileLength - firstPos;
outPercent = (groupContent * 100) / fileLength;
}
}
} else
this->NilStoreFileError(ev);
return outPercent;
}
void morkStore::SetStoreAndAllSpacesCanDirty(morkEnv* ev,
mork_bool inCanDirty) {
mStore_CanDirty = inCanDirty;
mork_change* c = 0;
mork_scope* key = 0; // ignore keys in maps
if (ev->Good()) {
morkAtomSpaceMapIter asi(ev, &mStore_AtomSpaces);
morkAtomSpace* atomSpace = 0; // old val node in the map
for (c = asi.FirstAtomSpace(ev, key, &atomSpace); c && ev->Good();
c = asi.NextAtomSpace(ev, key, &atomSpace)) {
if (atomSpace) {
if (atomSpace->IsAtomSpace())
atomSpace->mSpace_CanDirty = inCanDirty;
else
atomSpace->NonAtomSpaceTypeError(ev);
} else
ev->NilPointerError();
}
}
if (ev->Good()) {
morkRowSpaceMapIter rsi(ev, &mStore_RowSpaces);
morkRowSpace* rowSpace = 0; // old val node in the map
for (c = rsi.FirstRowSpace(ev, key, &rowSpace); c && ev->Good();
c = rsi.NextRowSpace(ev, key, &rowSpace)) {
if (rowSpace) {
if (rowSpace->IsRowSpace())
rowSpace->mSpace_CanDirty = inCanDirty;
else
rowSpace->NonRowSpaceTypeError(ev);
}
}
}
}
void morkStore::RenumberAllCollectableContent(morkEnv* ev) {
MORK_USED_1(ev);
// do nothing currently
}
nsIMdbStore* morkStore::AcquireStoreHandle(morkEnv* ev) { return this; }
morkFarBookAtom* morkStore::StageAliasAsFarBookAtom(morkEnv* ev,
const morkMid* inMid,
morkAtomSpace* ioSpace,
mork_cscode inForm) {
if (inMid && inMid->mMid_Buf) {
const morkBuf* buf = inMid->mMid_Buf;
mork_size length = buf->mBuf_Fill;
if (length <= morkBookAtom_kMaxBodySize) {
mork_aid dummyAid = 1;
// mStore_BookAtom.InitMaxBookAtom(ev, *buf,
// inForm, ioSpace, dummyAid);
mStore_FarBookAtom.InitFarBookAtom(ev, *buf, inForm, ioSpace, dummyAid);
return &mStore_FarBookAtom;
}
} else
ev->NilPointerError();
return (morkFarBookAtom*)0;
}
morkFarBookAtom* morkStore::StageYarnAsFarBookAtom(morkEnv* ev,
const mdbYarn* inYarn,
morkAtomSpace* ioSpace) {
if (inYarn && inYarn->mYarn_Buf) {
mork_size length = inYarn->mYarn_Fill;
if (length <= morkBookAtom_kMaxBodySize) {
morkBuf buf(inYarn->mYarn_Buf, length);
mork_aid dummyAid = 1;
// mStore_BookAtom.InitMaxBookAtom(ev, buf,
// inYarn->mYarn_Form, ioSpace, dummyAid);
mStore_FarBookAtom.InitFarBookAtom(ev, buf, inYarn->mYarn_Form, ioSpace,
dummyAid);
return &mStore_FarBookAtom;
}
} else
ev->NilPointerError();
return (morkFarBookAtom*)0;
}
morkFarBookAtom* morkStore::StageStringAsFarBookAtom(morkEnv* ev,
const char* inString,
mork_cscode inForm,
morkAtomSpace* ioSpace) {
if (inString) {
mork_size length = strlen(inString);
if (length <= morkBookAtom_kMaxBodySize) {
morkBuf buf(inString, length);
mork_aid dummyAid = 1;
// mStore_BookAtom.InitMaxBookAtom(ev, buf, inForm, ioSpace, dummyAid);
mStore_FarBookAtom.InitFarBookAtom(ev, buf, inForm, ioSpace, dummyAid);
return &mStore_FarBookAtom;
}
} else
ev->NilPointerError();
return (morkFarBookAtom*)0;
}
morkAtomSpace* morkStore::LazyGetOidAtomSpace(morkEnv* ev) {
MORK_USED_1(ev);
if (!mStore_OidAtomSpace) {
}
return mStore_OidAtomSpace;
}
morkAtomSpace* morkStore::LazyGetGroundAtomSpace(morkEnv* ev) {
if (!mStore_GroundAtomSpace) {
mork_scope atomScope = morkStore_kValueSpaceScope;
nsIMdbHeap* heap = mPort_Heap;
morkAtomSpace* space = new (*heap, ev)
morkAtomSpace(ev, morkUsage::kHeap, atomScope, this, heap, heap);
if (space) // successful space creation?
{
this->MaybeDirtyStore();
mStore_GroundAtomSpace = space; // transfer strong ref to this slot
mStore_AtomSpaces.AddAtomSpace(ev, space);
}
}
return mStore_GroundAtomSpace;
}
morkAtomSpace* morkStore::LazyGetGroundColumnSpace(morkEnv* ev) {
if (!mStore_GroundColumnSpace) {
mork_scope atomScope = morkStore_kGroundColumnSpace;
nsIMdbHeap* heap = mPort_Heap;
morkAtomSpace* space = new (*heap, ev)
morkAtomSpace(ev, morkUsage::kHeap, atomScope, this, heap, heap);
if (space) // successful space creation?
{
this->MaybeDirtyStore();
mStore_GroundColumnSpace = space; // transfer strong ref to this slot
mStore_AtomSpaces.AddAtomSpace(ev, space);
}
}
return mStore_GroundColumnSpace;
}
morkStream* morkStore::LazyGetInStream(morkEnv* ev) {
if (!mStore_InStream) {
nsIMdbFile* file = mStore_File;
if (file) {
morkStream* stream = new (*mPort_Heap, ev)
morkStream(ev, morkUsage::kHeap, mPort_Heap, file,
morkStore_kStreamBufSize, /*frozen*/ morkBool_kTrue);
if (stream) {
this->MaybeDirtyStore();
mStore_InStream = stream; // transfer strong ref to this slot
}
} else
this->NilStoreFileError(ev);
}
return mStore_InStream;
}
morkStream* morkStore::LazyGetOutStream(morkEnv* ev) {
if (!mStore_OutStream) {
nsIMdbFile* file = mStore_File;
if (file) {
morkStream* stream = new (*mPort_Heap, ev)
morkStream(ev, morkUsage::kHeap, mPort_Heap, file,
morkStore_kStreamBufSize, /*frozen*/ morkBool_kFalse);
if (stream) {
this->MaybeDirtyStore();
mStore_InStream = stream; // transfer strong ref to this slot
}
} else
this->NilStoreFileError(ev);
}
return mStore_OutStream;
}
void morkStore::ForgetBuilder(morkEnv* ev) {
if (mStore_Builder)
morkBuilder::SlotStrongBuilder((morkBuilder*)0, ev, &mStore_Builder);
if (mStore_InStream)
morkStream::SlotStrongStream((morkStream*)0, ev, &mStore_InStream);
}
morkBuilder* morkStore::LazyGetBuilder(morkEnv* ev) {
if (!mStore_Builder) {
morkStream* stream = this->LazyGetInStream(ev);
if (stream) {
nsIMdbHeap* heap = mPort_Heap;
morkBuilder* builder = new (*heap, ev)
morkBuilder(ev, morkUsage::kHeap, heap, stream,
morkBuilder_kDefaultBytesPerParseSegment, heap, this);
if (builder) {
mStore_Builder = builder; // transfer strong ref to this slot
}
}
}
return mStore_Builder;
}
morkRowSpace* morkStore::LazyGetRowSpace(morkEnv* ev, mdb_scope inRowScope) {
morkRowSpace* outSpace = mStore_RowSpaces.GetRowSpace(ev, inRowScope);
if (!outSpace && ev->Good()) // try to make new space?
{
nsIMdbHeap* heap = mPort_Heap;
outSpace = new (*heap, ev)
morkRowSpace(ev, morkUsage::kHeap, inRowScope, this, heap, heap);
if (outSpace) // successful space creation?
{
this->MaybeDirtyStore();
// note adding to node map creates its own strong ref...
if (mStore_RowSpaces.AddRowSpace(ev, outSpace))
outSpace->CutStrongRef(ev); // ...so we can drop our strong ref
}
}
return outSpace;
}
morkAtomSpace* morkStore::LazyGetAtomSpace(morkEnv* ev, mdb_scope inAtomScope) {
morkAtomSpace* outSpace = mStore_AtomSpaces.GetAtomSpace(ev, inAtomScope);
if (!outSpace && ev->Good()) // try to make new space?
{
if (inAtomScope == morkStore_kValueSpaceScope)
outSpace = this->LazyGetGroundAtomSpace(ev);
else if (inAtomScope == morkStore_kGroundColumnSpace)
outSpace = this->LazyGetGroundColumnSpace(ev);
else {
nsIMdbHeap* heap = mPort_Heap;
outSpace = new (*heap, ev)
morkAtomSpace(ev, morkUsage::kHeap, inAtomScope, this, heap, heap);
if (outSpace) // successful space creation?
{
this->MaybeDirtyStore();
// note adding to node map creates its own strong ref...
if (mStore_AtomSpaces.AddAtomSpace(ev, outSpace))
outSpace->CutStrongRef(ev); // ...so we can drop our strong ref
}
}
}
return outSpace;
}
/*static*/ void morkStore::NonStoreTypeError(morkEnv* ev) {
ev->NewError("non morkStore");
}
/*static*/ void morkStore::NilStoreFileError(morkEnv* ev) {
ev->NewError("nil mStore_File");
}
/*static*/ void morkStore::CannotAutoAssignAtomIdentityError(morkEnv* ev) {
ev->NewError("false mStore_CanAutoAssignAtomIdentity");
}
mork_bool morkStore::OpenStoreFile(
morkEnv* ev, mork_bool inFrozen,
// const char* inFilePath,
nsIMdbFile* ioFile, // db abstract file interface
const mdbOpenPolicy* inOpenPolicy) {
MORK_USED_2(inOpenPolicy, inFrozen);
nsIMdbFile_SlotStrongFile(ioFile, ev, &mStore_File);
// if ( ev->Good() )
// {
// morkFile* file = morkFile::OpenOldFile(ev, mPort_Heap,
// inFilePath, inFrozen);
// if ( ioFile )
// {
// if ( ev->Good() )
// morkFile::SlotStrongFile(file, ev, &mStore_File);
// else
// file->CutStrongRef(ev);
//
// }
// }
return ev->Good();
}
mork_bool morkStore::CreateStoreFile(
morkEnv* ev,
// const char* inFilePath,
nsIMdbFile* ioFile, // db abstract file interface
const mdbOpenPolicy* inOpenPolicy) {
MORK_USED_1(inOpenPolicy);
nsIMdbFile_SlotStrongFile(ioFile, ev, &mStore_File);
return ev->Good();
}
morkAtom* morkStore::CopyAtom(morkEnv* ev, const morkAtom* inAtom)
// copy inAtom (from some other store) over to this store
{
morkAtom* outAtom = 0;
if (inAtom) {
mdbYarn yarn;
if (morkAtom::AliasYarn(inAtom, &yarn))
outAtom = this->YarnToAtom(ev, &yarn, true /* create */);
}
return outAtom;
}
morkAtom* morkStore::YarnToAtom(morkEnv* ev, const mdbYarn* inYarn,
bool createIfMissing /* = true */) {
morkAtom* outAtom = 0;
if (ev->Good()) {
morkAtomSpace* groundSpace = this->LazyGetGroundAtomSpace(ev);
if (groundSpace) {
morkFarBookAtom* keyAtom =
this->StageYarnAsFarBookAtom(ev, inYarn, groundSpace);
if (keyAtom) {
morkAtomBodyMap* map = &groundSpace->mAtomSpace_AtomBodies;
outAtom = map->GetAtom(ev, keyAtom);
if (!outAtom && createIfMissing) {
this->MaybeDirtyStore();
outAtom = groundSpace->MakeBookAtomCopy(ev, *keyAtom);
}
} else if (ev->Good()) {
morkBuf b(inYarn->mYarn_Buf, inYarn->mYarn_Fill);
morkZone* z = &mStore_Zone;
outAtom = mStore_Pool.NewAnonAtom(ev, b, inYarn->mYarn_Form, z);
}
}
}
return outAtom;
}
mork_bool morkStore::MidToOid(morkEnv* ev, const morkMid& inMid,
mdbOid* outOid) {
*outOid = inMid.mMid_Oid;
const morkBuf* buf = inMid.mMid_Buf;
if (buf && !outOid->mOid_Scope) {
if (buf->mBuf_Fill <= morkBookAtom_kMaxBodySize) {
if (buf->mBuf_Fill == 1) {
mork_u1* name = (mork_u1*)buf->mBuf_Body;
if (name) {
outOid->mOid_Scope = (mork_scope)*name;
return ev->Good();
}
}
morkAtomSpace* groundSpace = this->LazyGetGroundColumnSpace(ev);
if (groundSpace) {
mork_cscode form = 0; // default
mork_aid aid = 1; // dummy
mStore_FarBookAtom.InitFarBookAtom(ev, *buf, form, groundSpace, aid);
morkFarBookAtom* keyAtom = &mStore_FarBookAtom;
morkAtomBodyMap* map = &groundSpace->mAtomSpace_AtomBodies;
morkBookAtom* bookAtom = map->GetAtom(ev, keyAtom);
if (bookAtom)
outOid->mOid_Scope = bookAtom->mBookAtom_Id;
else {
this->MaybeDirtyStore();
bookAtom = groundSpace->MakeBookAtomCopy(ev, *keyAtom);
if (bookAtom) {
outOid->mOid_Scope = bookAtom->mBookAtom_Id;
bookAtom->MakeCellUseForever(ev);
}
}
}
}
}
return ev->Good();
}
morkRow* morkStore::MidToRow(morkEnv* ev, const morkMid& inMid) {
mdbOid tempOid;
this->MidToOid(ev, inMid, &tempOid);
return this->OidToRow(ev, &tempOid);
}
morkTable* morkStore::MidToTable(morkEnv* ev, const morkMid& inMid) {
mdbOid tempOid;
this->MidToOid(ev, inMid, &tempOid);
return this->OidToTable(ev, &tempOid, /*metarow*/ (mdbOid*)0);
}
mork_bool morkStore::MidToYarn(morkEnv* ev, const morkMid& inMid,
mdbYarn* outYarn) {
mdbOid tempOid;
this->MidToOid(ev, inMid, &tempOid);
return this->OidToYarn(ev, tempOid, outYarn);
}
mork_bool morkStore::OidToYarn(morkEnv* ev, const mdbOid& inOid,
mdbYarn* outYarn) {
morkBookAtom* atom = 0;
morkAtomSpace* atomSpace =
mStore_AtomSpaces.GetAtomSpace(ev, inOid.mOid_Scope);
if (atomSpace) {
morkAtomAidMap* map = &atomSpace->mAtomSpace_AtomAids;
atom = map->GetAid(ev, (mork_aid)inOid.mOid_Id);
}
morkAtom::GetYarn(atom, outYarn);
return ev->Good();
}
morkBookAtom* morkStore::MidToAtom(morkEnv* ev, const morkMid& inMid) {
morkBookAtom* outAtom = 0;
mdbOid oid;
if (this->MidToOid(ev, inMid, &oid)) {
morkAtomSpace* atomSpace =
mStore_AtomSpaces.GetAtomSpace(ev, oid.mOid_Scope);
if (atomSpace) {
morkAtomAidMap* map = &atomSpace->mAtomSpace_AtomAids;
outAtom = map->GetAid(ev, (mork_aid)oid.mOid_Id);
}
}
return outAtom;
}
/*static*/ void morkStore::SmallTokenToOneByteYarn(morkEnv* ev,
mdb_token inToken,
mdbYarn* outYarn) {
MORK_USED_1(ev);
if (outYarn->mYarn_Buf && outYarn->mYarn_Size) // any space in yarn at all?
{
mork_u1* buf = (mork_u1*)outYarn->mYarn_Buf; // for byte arithmetic
buf[0] = (mork_u1)inToken; // write the single byte
outYarn->mYarn_Fill = 1;
outYarn->mYarn_More = 0;
} else // just record we could not write the single byte
{
outYarn->mYarn_More = 1;
outYarn->mYarn_Fill = 0;
}
}
void morkStore::TokenToString(morkEnv* ev, mdb_token inToken,
mdbYarn* outTokenName) {
if (inToken > morkAtomSpace_kMaxSevenBitAid) {
morkBookAtom* atom = 0;
morkAtomSpace* space = mStore_GroundColumnSpace;
if (space) atom = space->mAtomSpace_AtomAids.GetAid(ev, (mork_aid)inToken);
morkAtom::GetYarn(atom, outTokenName);
} else // token is an "immediate" single byte string representation?
this->SmallTokenToOneByteYarn(ev, inToken, outTokenName);
}
// void
// morkStore::SyncTokenIdChange(morkEnv* ev, const morkBookAtom* inAtom,
// const mdbOid* inOid)
// {
// mork_token mStore_MorkNoneToken; // token for "mork:none" // fill=9
// mork_column mStore_CharsetToken; // token for "charset" // fill=7
// mork_column mStore_AtomScopeToken; // token for "atomScope" // fill=9
// mork_column mStore_RowScopeToken; // token for "rowScope" // fill=8
// mork_column mStore_TableScopeToken; // token for "tableScope" // fill=10
// mork_column mStore_ColumnScopeToken; // token for "columnScope" // fill=11
// mork_kind mStore_TableKindToken; // token for "tableKind" // fill=9
// ---------------------ruler-for-token-length-above---123456789012
//
// if ( inOid->mOid_Scope == morkStore_kColumnSpaceScope &&
// inAtom->IsWeeBook() )
// {
// const mork_u1* body = ((const morkWeeBookAtom*)
// inAtom)->mWeeBookAtom_Body; mork_size size = inAtom->mAtom_Size;
//
// if ( size >= 7 && size <= 11 )
// {
// if ( size == 9 )
// {
// if ( *body == 'm' )
// {
// if ( MORK_MEMCMP(body, "mork:none", 9) == 0 )
// mStore_MorkNoneToken = inAtom->mBookAtom_Id;
// }
// else if ( *body == 'a' )
// {
// if ( MORK_MEMCMP(body, "atomScope", 9) == 0 )
// mStore_AtomScopeToken = inAtom->mBookAtom_Id;
// }
// else if ( *body == 't' )
// {
// if ( MORK_MEMCMP(body, "tableKind", 9) == 0 )
// mStore_TableKindToken = inAtom->mBookAtom_Id;
// }
// }
// else if ( size == 7 && *body == 'c' )
// {
// if ( MORK_MEMCMP(body, "charset", 7) == 0 )
// mStore_CharsetToken = inAtom->mBookAtom_Id;
// }
// else if ( size == 8 && *body == 'r' )
// {
// if ( MORK_MEMCMP(body, "rowScope", 8) == 0 )
// mStore_RowScopeToken = inAtom->mBookAtom_Id;
// }
// else if ( size == 10 && *body == 't' )
// {
// if ( MORK_MEMCMP(body, "tableScope", 10) == 0 )
// mStore_TableScopeToken = inAtom->mBookAtom_Id;
// }
// else if ( size == 11 && *body == 'c' )
// {
// if ( MORK_MEMCMP(body, "columnScope", 11) == 0 )
// mStore_ColumnScopeToken = inAtom->mBookAtom_Id;
// }
// }
// }
// }
morkAtom* morkStore::AddAlias(morkEnv* ev, const morkMid& inMid,
mork_cscode inForm) {
morkBookAtom* outAtom = 0;
if (ev->Good()) {
const mdbOid* oid = &inMid.mMid_Oid;
morkAtomSpace* atomSpace = this->LazyGetAtomSpace(ev, oid->mOid_Scope);
if (atomSpace) {
morkFarBookAtom* keyAtom =
this->StageAliasAsFarBookAtom(ev, &inMid, atomSpace, inForm);
if (keyAtom) {
morkAtomAidMap* map = &atomSpace->mAtomSpace_AtomAids;
outAtom = map->GetAid(ev, (mork_aid)oid->mOid_Id);
if (outAtom) {
if (!outAtom->EqualFormAndBody(ev, keyAtom))
ev->NewError("duplicate alias ID");
} else {
this->MaybeDirtyStore();
keyAtom->mBookAtom_Id = oid->mOid_Id;
outAtom = atomSpace->MakeBookAtomCopyWithAid(ev, *keyAtom,
(mork_aid)oid->mOid_Id);
// if ( outAtom && outAtom->IsWeeBook() )
// {
// if ( oid->mOid_Scope == morkStore_kColumnSpaceScope )
// {
// mork_size size = outAtom->mAtom_Size;
// if ( size >= 7 && size <= 11 )
// this->SyncTokenIdChange(ev, outAtom, oid);
// }
// }
}
}
}
}
return outAtom;
}
#define morkStore_kMaxCopyTokenSize 512 /* if larger, cannot be copied */
mork_token morkStore::CopyToken(morkEnv* ev, mdb_token inToken,
morkStore* inStore)
// copy inToken from inStore over to this store
{
mork_token outToken = 0;
if (inStore == this) // same store?
outToken = inToken; // just return token unchanged
else {
char yarnBuf[morkStore_kMaxCopyTokenSize];
mdbYarn yarn;
yarn.mYarn_Buf = yarnBuf;
yarn.mYarn_Fill = 0;
yarn.mYarn_Size = morkStore_kMaxCopyTokenSize;
yarn.mYarn_More = 0;
yarn.mYarn_Form = 0;
yarn.mYarn_Grow = 0;
inStore->TokenToString(ev, inToken, &yarn);
if (ev->Good()) {
morkBuf buf(yarn.mYarn_Buf, yarn.mYarn_Fill);
outToken = this->BufToToken(ev, &buf);
}
}
return outToken;
}
mork_token morkStore::BufToToken(morkEnv* ev, const morkBuf* inBuf) {
mork_token outToken = 0;
if (ev->Good()) {
const mork_u1* s = (const mork_u1*)inBuf->mBuf_Body;
mork_bool nonAscii = (*s > 0x7F);
mork_size length = inBuf->mBuf_Fill;
if (nonAscii || length > 1) // more than one byte?
{
mork_cscode form = 0; // default charset
morkAtomSpace* space = this->LazyGetGroundColumnSpace(ev);
if (space) {
morkFarBookAtom* keyAtom = 0;
if (length <= morkBookAtom_kMaxBodySize) {
mork_aid aid = 1; // dummy
// mStore_BookAtom.InitMaxBookAtom(ev, *inBuf, form, space, aid);
mStore_FarBookAtom.InitFarBookAtom(ev, *inBuf, form, space, aid);
keyAtom = &mStore_FarBookAtom;
}
if (keyAtom) {
morkAtomBodyMap* map = &space->mAtomSpace_AtomBodies;
morkBookAtom* bookAtom = map->GetAtom(ev, keyAtom);
if (bookAtom)
outToken = bookAtom->mBookAtom_Id;
else {
this->MaybeDirtyStore();
bookAtom = space->MakeBookAtomCopy(ev, *keyAtom);
if (bookAtom) {
outToken = bookAtom->mBookAtom_Id;
bookAtom->MakeCellUseForever(ev);
}
}
}
}
} else // only a single byte in inTokenName string:
outToken = *s;
}
return outToken;
}
mork_token morkStore::StringToToken(morkEnv* ev, const char* inTokenName) {
mork_token outToken = 0;
if (ev->Good()) {
const mork_u1* s = (const mork_u1*)inTokenName;
mork_bool nonAscii = (*s > 0x7F);
if (nonAscii || (*s && s[1])) // more than one byte?
{
mork_cscode form = 0; // default charset
morkAtomSpace* groundSpace = this->LazyGetGroundColumnSpace(ev);
if (groundSpace) {
morkFarBookAtom* keyAtom =
this->StageStringAsFarBookAtom(ev, inTokenName, form, groundSpace);
if (keyAtom) {
morkAtomBodyMap* map = &groundSpace->mAtomSpace_AtomBodies;
morkBookAtom* bookAtom = map->GetAtom(ev, keyAtom);
if (bookAtom)
outToken = bookAtom->mBookAtom_Id;
else {
this->MaybeDirtyStore();
bookAtom = groundSpace->MakeBookAtomCopy(ev, *keyAtom);
if (bookAtom) {
outToken = bookAtom->mBookAtom_Id;
bookAtom->MakeCellUseForever(ev);
}
}
}
}
} else // only a single byte in inTokenName string:
outToken = *s;
}
return outToken;
}
mork_token morkStore::QueryToken(morkEnv* ev, const char* inTokenName) {
mork_token outToken = 0;
if (ev->Good()) {
const mork_u1* s = (const mork_u1*)inTokenName;
mork_bool nonAscii = (*s > 0x7F);
if (nonAscii || (*s && s[1])) // more than one byte?
{
mork_cscode form = 0; // default charset
morkAtomSpace* groundSpace = this->LazyGetGroundColumnSpace(ev);
if (groundSpace) {
morkFarBookAtom* keyAtom =
this->StageStringAsFarBookAtom(ev, inTokenName, form, groundSpace);
if (keyAtom) {
morkAtomBodyMap* map = &groundSpace->mAtomSpace_AtomBodies;
morkBookAtom* bookAtom = map->GetAtom(ev, keyAtom);
if (bookAtom) {
outToken = bookAtom->mBookAtom_Id;
bookAtom->MakeCellUseForever(ev);
}
}
}
} else // only a single byte in inTokenName string:
outToken = *s;
}
return outToken;
}
mork_bool morkStore::HasTableKind(morkEnv* ev, mdb_scope inRowScope,
mdb_kind inTableKind,
mdb_count* outTableCount) {
MORK_USED_2(inRowScope, inTableKind);
mork_bool outBool = morkBool_kFalse;
mdb_count tableCount = 0;
ev->StubMethodOnlyError();
if (outTableCount) *outTableCount = tableCount;
return outBool;
}
morkTable* morkStore::GetTableKind(morkEnv* ev, mdb_scope inRowScope,
mdb_kind inTableKind,
mdb_count* outTableCount,
mdb_bool* outMustBeUnique) {
morkTable* outTable = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inRowScope);
if (rowSpace) {
outTable = rowSpace->FindTableByKind(ev, inTableKind);
if (outTable) {
if (outTableCount) *outTableCount = outTable->GetRowCount();
if (outMustBeUnique) *outMustBeUnique = outTable->IsTableUnique();
}
}
}
return outTable;
}
morkRow* morkStore::FindRow(morkEnv* ev, mdb_scope inScope, mdb_column inColumn,
const mdbYarn* inYarn) {
morkRow* outRow = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inScope);
if (rowSpace) {
outRow = rowSpace->FindRow(ev, inColumn, inYarn);
}
}
return outRow;
}
morkRow* morkStore::GetRow(morkEnv* ev, const mdbOid* inOid) {
morkRow* outRow = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inOid->mOid_Scope);
if (rowSpace) {
outRow = rowSpace->mRowSpace_Rows.GetOid(ev, inOid);
}
}
return outRow;
}
morkTable* morkStore::GetTable(morkEnv* ev, const mdbOid* inOid) {
morkTable* outTable = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inOid->mOid_Scope);
if (rowSpace) {
outTable = rowSpace->FindTableByTid(ev, inOid->mOid_Id);
}
}
return outTable;
}
morkTable* morkStore::NewTable(
morkEnv* ev, mdb_scope inRowScope, mdb_kind inTableKind,
mdb_bool inMustBeUnique,
const mdbOid* inOptionalMetaRowOid) // can be nil to avoid specifying
{
morkTable* outTable = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inRowScope);
if (rowSpace)
outTable = rowSpace->NewTable(ev, inTableKind, inMustBeUnique,
inOptionalMetaRowOid);
}
return outTable;
}
morkPortTableCursor* morkStore::GetPortTableCursor(morkEnv* ev,
mdb_scope inRowScope,
mdb_kind inTableKind) {
morkPortTableCursor* outCursor = 0;
if (ev->Good()) {
nsIMdbHeap* heap = mPort_Heap;
outCursor = new (*heap, ev) morkPortTableCursor(
ev, morkUsage::kHeap, heap, this, inRowScope, inTableKind, heap);
}
NS_IF_ADDREF(outCursor);
return outCursor;
}
morkRow* morkStore::NewRow(morkEnv* ev, mdb_scope inRowScope) {
morkRow* outRow = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inRowScope);
if (rowSpace) outRow = rowSpace->NewRow(ev);
}
return outRow;
}
morkRow* morkStore::NewRowWithOid(morkEnv* ev, const mdbOid* inOid) {
morkRow* outRow = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inOid->mOid_Scope);
if (rowSpace) outRow = rowSpace->NewRowWithOid(ev, inOid);
}
return outRow;
}
morkRow* morkStore::OidToRow(morkEnv* ev, const mdbOid* inOid)
// OidToRow() finds old row with oid, or makes new one if not found.
{
morkRow* outRow = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inOid->mOid_Scope);
if (rowSpace) {
outRow = rowSpace->mRowSpace_Rows.GetOid(ev, inOid);
if (!outRow && ev->Good()) outRow = rowSpace->NewRowWithOid(ev, inOid);
}
}
return outRow;
}
morkTable* morkStore::OidToTable(
morkEnv* ev, const mdbOid* inOid,
const mdbOid* inOptionalMetaRowOid) // can be nil to avoid specifying
// OidToTable() finds old table with oid, or makes new one if not found.
{
morkTable* outTable = 0;
if (ev->Good()) {
morkRowSpace* rowSpace = this->LazyGetRowSpace(ev, inOid->mOid_Scope);
if (rowSpace) {
outTable = rowSpace->mRowSpace_Tables.GetTable(ev, inOid->mOid_Id);
if (!outTable && ev->Good()) {
mork_kind tableKind = morkStore_kNoneToken;
outTable = rowSpace->NewTableWithTid(ev, inOid->mOid_Id, tableKind,
inOptionalMetaRowOid);
}
}
}
return outTable;
}
// { ===== begin nsIMdbObject methods =====
// { ----- begin ref counting for well-behaved cyclic graphs -----
NS_IMETHODIMP
morkStore::GetWeakRefCount(nsIMdbEnv* mev, // weak refs
mdb_count* outCount) {
*outCount = WeakRefsOnly();
return NS_OK;
}
NS_IMETHODIMP
morkStore::GetStrongRefCount(nsIMdbEnv* mev, // strong refs
mdb_count* outCount) {
*outCount = StrongRefsOnly();
return NS_OK;
}
// ### TODO - clean up this cast, if required
NS_IMETHODIMP
morkStore::AddWeakRef(nsIMdbEnv* mev) {
morkEnv* ev = morkEnv::FromMdbEnv(mev);
// XXX Casting mork_refs to nsresult
return static_cast<nsresult>(morkNode::AddWeakRef(ev));
}
#ifndef _MSC_VER
NS_IMETHODIMP_(mork_uses)
morkStore::AddStrongRef(morkEnv* mev) { return AddRef(); }
#endif
NS_IMETHODIMP_(mork_uses)
morkStore::AddStrongRef(nsIMdbEnv* mev) { return AddRef(); }
NS_IMETHODIMP
morkStore::CutWeakRef(nsIMdbEnv* mev) {
morkEnv* ev = morkEnv::FromMdbEnv(mev);
// XXX Casting mork_refs to nsresult
return static_cast<nsresult>(morkNode::CutWeakRef(ev));
}
#ifndef _MSC_VER
NS_IMETHODIMP_(mork_uses)
morkStore::CutStrongRef(morkEnv* mev) { return Release(); }
#endif
NS_IMETHODIMP
morkStore::CutStrongRef(nsIMdbEnv* mev) {
// XXX Casting nsrefcnt to nsresult
return static_cast<nsresult>(Release());
}
NS_IMETHODIMP
morkStore::CloseMdbObject(nsIMdbEnv* mev) {
morkEnv* ev = morkEnv::FromMdbEnv(mev);
CloseMorkNode(ev);
Release();
return NS_OK;
}
NS_IMETHODIMP
morkStore::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen) {
*outOpen = IsOpenNode();
return NS_OK;
}
// } ----- end ref counting -----
// } ===== end nsIMdbObject methods =====
// { ===== begin nsIMdbPort methods =====
// { ----- begin attribute methods -----
NS_IMETHODIMP
morkStore::GetIsPortReadonly(nsIMdbEnv* mev, mdb_bool* outBool) {
nsresult outErr = NS_OK;
mdb_bool isReadOnly = morkBool_kFalse;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
ev->StubMethodOnlyError();
outErr = ev->AsErr();
}
if (outBool) *outBool = isReadOnly;
return outErr;
}
morkEnv* morkStore::CanUseStore(nsIMdbEnv* mev, mork_bool inMutable,
nsresult* outErr) const {
morkEnv* outEnv = 0;
morkEnv* ev = morkEnv::FromMdbEnv(mev);
if (ev) {
if (IsStore())
outEnv = ev;
else
NonStoreTypeError(ev);
*outErr = ev->AsErr();
}
MORK_ASSERT(outEnv);
return outEnv;
}
NS_IMETHODIMP
morkStore::GetIsStore(nsIMdbEnv* mev, mdb_bool* outBool) {
MORK_USED_1(mev);
if (outBool) *outBool = morkBool_kTrue;
return NS_OK;
}
NS_IMETHODIMP
morkStore::GetIsStoreAndDirty(nsIMdbEnv* mev, mdb_bool* outBool) {
nsresult outErr = NS_OK;
mdb_bool isStoreAndDirty = morkBool_kFalse;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
ev->StubMethodOnlyError();
outErr = ev->AsErr();
}
if (outBool) *outBool = isStoreAndDirty;
return outErr;
}
NS_IMETHODIMP
morkStore::GetUsagePolicy(nsIMdbEnv* mev, mdbUsagePolicy* ioUsagePolicy) {
MORK_USED_1(ioUsagePolicy);
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
ev->StubMethodOnlyError();
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::SetUsagePolicy(nsIMdbEnv* mev, const mdbUsagePolicy* inUsagePolicy) {
MORK_USED_1(inUsagePolicy);
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing?
outErr = ev->AsErr();
}
return outErr;
}
// } ----- end attribute methods -----
// { ----- begin memory policy methods -----
NS_IMETHODIMP
morkStore::IdleMemoryPurge( // do memory management already scheduled
nsIMdbEnv* mev, // context
mdb_size* outEstimatedBytesFreed) // approximate bytes actually freed
{
nsresult outErr = NS_OK;
mdb_size estimatedBytesFreed = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing?
outErr = ev->AsErr();
}
if (outEstimatedBytesFreed) *outEstimatedBytesFreed = estimatedBytesFreed;
return outErr;
}
NS_IMETHODIMP
morkStore::SessionMemoryPurge( // request specific footprint decrease
nsIMdbEnv* mev, // context
mdb_size inDesiredBytesFreed, // approximate number of bytes wanted
mdb_size* outEstimatedBytesFreed) // approximate bytes actually freed
{
MORK_USED_1(inDesiredBytesFreed);
nsresult outErr = NS_OK;
mdb_size estimate = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing?
outErr = ev->AsErr();
}
if (outEstimatedBytesFreed) *outEstimatedBytesFreed = estimate;
return outErr;
}
NS_IMETHODIMP
morkStore::PanicMemoryPurge( // desperately free all possible memory
nsIMdbEnv* mev, // context
mdb_size* outEstimatedBytesFreed) // approximate bytes actually freed
{
nsresult outErr = NS_OK;
mdb_size estimate = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing?
outErr = ev->AsErr();
}
if (outEstimatedBytesFreed) *outEstimatedBytesFreed = estimate;
return outErr;
}
// } ----- end memory policy methods -----
// { ----- begin filepath methods -----
NS_IMETHODIMP
morkStore::GetPortFilePath(
nsIMdbEnv* mev, // context
mdbYarn* outFilePath, // name of file holding port content
mdbYarn* outFormatVersion) // file format description
{
nsresult outErr = NS_OK;
if (outFormatVersion) outFormatVersion->mYarn_Fill = 0;
if (outFilePath) outFilePath->mYarn_Fill = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
if (mStore_File)
mStore_File->Path(mev, outFilePath);
else
NilStoreFileError(ev);
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::GetPortFile(
nsIMdbEnv* mev, // context
nsIMdbFile** acqFile) // acquire file used by port or store
{
nsresult outErr = NS_OK;
if (acqFile) *acqFile = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
if (mStore_File) {
if (acqFile) {
mStore_File->AddRef();
if (ev->Good()) *acqFile = mStore_File;
}
} else
NilStoreFileError(ev);
outErr = ev->AsErr();
}
return outErr;
}
// } ----- end filepath methods -----
// { ----- begin export methods -----
NS_IMETHODIMP
morkStore::BestExportFormat( // determine preferred export format
nsIMdbEnv* mev, // context
mdbYarn* outFormatVersion) // file format description
{
nsresult outErr = NS_OK;
if (outFormatVersion) outFormatVersion->mYarn_Fill = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
ev->StubMethodOnlyError();
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::CanExportToFormat( // can export content in given specific format?
nsIMdbEnv* mev, // context
const char* inFormatVersion, // file format description
mdb_bool* outCanExport) // whether ExportSource() might succeed
{
MORK_USED_1(inFormatVersion);
mdb_bool canExport = morkBool_kFalse;
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
ev->StubMethodOnlyError();
outErr = ev->AsErr();
}
if (outCanExport) *outCanExport = canExport;
return outErr;
}
NS_IMETHODIMP
morkStore::ExportToFormat( // export content in given specific format
nsIMdbEnv* mev, // context
// const char* inFilePath, // the file to receive exported content
nsIMdbFile* ioFile, // destination abstract file interface
const char* inFormatVersion, // file format description
nsIMdbThumb** acqThumb) // acquire thumb for incremental export
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the export will be finished.
{
nsresult outErr = NS_OK;
nsIMdbThumb* outThumb = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
if (ioFile && inFormatVersion && acqThumb) {
ev->StubMethodOnlyError();
} else
ev->NilPointerError();
outErr = ev->AsErr();
}
if (acqThumb) *acqThumb = outThumb;
return outErr;
}
// } ----- end export methods -----
// { ----- begin token methods -----
NS_IMETHODIMP
morkStore::TokenToString( // return a string name for an integer token
nsIMdbEnv* mev, // context
mdb_token inToken, // token for inTokenName inside this port
mdbYarn* outTokenName) // the type of table to access
{
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
TokenToString(ev, inToken, outTokenName);
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::StringToToken( // return an integer token for scope name
nsIMdbEnv* mev, // context
const char* inTokenName, // Latin1 string to tokenize if possible
mdb_token* outToken) // token for inTokenName inside this port
// String token zero is never used and never supported. If the port
// is a mutable store, then StringToToken() to create a new
// association of inTokenName with a new integer token if possible.
// But a readonly port will return zero for an unknown scope name.
{
nsresult outErr = NS_OK;
mdb_token token = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
token = StringToToken(ev, inTokenName);
outErr = ev->AsErr();
}
if (outToken) *outToken = token;
return outErr;
}
NS_IMETHODIMP
morkStore::QueryToken( // like StringToToken(), but without adding
nsIMdbEnv* mev, // context
const char* inTokenName, // Latin1 string to tokenize if possible
mdb_token* outToken) // token for inTokenName inside this port
// QueryToken() will return a string token if one already exists,
// but unlike StringToToken(), will not assign a new token if not
// already in use.
{
nsresult outErr = NS_OK;
mdb_token token = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
token = QueryToken(ev, inTokenName);
outErr = ev->AsErr();
}
if (outToken) *outToken = token;
return outErr;
}
// } ----- end token methods -----
// { ----- begin row methods -----
NS_IMETHODIMP
morkStore::HasRow( // contains a row with the specified oid?
nsIMdbEnv* mev, // context
const mdbOid* inOid, // hypothetical row oid
mdb_bool* outHasRow) // whether GetRow() might succeed
{
nsresult outErr = NS_OK;
mdb_bool hasRow = morkBool_kFalse;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = GetRow(ev, inOid);
if (row) hasRow = morkBool_kTrue;
outErr = ev->AsErr();
}
if (outHasRow) *outHasRow = hasRow;
return outErr;
}
NS_IMETHODIMP
morkStore::GetRow( // access one row with specific oid
nsIMdbEnv* mev, // context
const mdbOid* inOid, // hypothetical row oid
nsIMdbRow** acqRow) // acquire specific row (or null)
{
nsresult outErr = NS_OK;
nsIMdbRow* outRow = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = GetRow(ev, inOid);
if (row && ev->Good()) outRow = row->AcquireRowHandle(ev, this);
outErr = ev->AsErr();
}
if (acqRow) *acqRow = outRow;
return outErr;
}
NS_IMETHODIMP
morkStore::GetRowRefCount( // get number of tables that contain a row
nsIMdbEnv* mev, // context
const mdbOid* inOid, // hypothetical row oid
mdb_count* outRefCount) // number of tables containing inRowKey
{
nsresult outErr = NS_OK;
mdb_count count = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = GetRow(ev, inOid);
if (row && ev->Good()) count = row->mRow_GcUses;
outErr = ev->AsErr();
}
if (outRefCount) *outRefCount = count;
return outErr;
}
NS_IMETHODIMP
morkStore::FindRow(
nsIMdbEnv* mev, // search for row with matching cell
mdb_scope inRowScope, // row scope for row ids
mdb_column inColumn, // the column to search (and maintain an index)
const mdbYarn* inTargetCellValue, // cell value for which to search
mdbOid* outRowOid, // out row oid on match (or {0,-1} for no match)
nsIMdbRow** acqRow) // acquire matching row (or nil for no match)
// FindRow() searches for one row that has a cell in column inColumn with
// a contained value with the same form (i.e. charset) and is byte-wise
// identical to the blob described by yarn inTargetCellValue. Both content
// and form of the yarn must be an exact match to find a matching row.
//
// (In other words, both a yarn's blob bytes and form are significant. The
// form is not expected to vary in columns used for identity anyway. This
// is intended to make the cost of FindRow() cheaper for MDB implementors,
// since any cell value atomization performed internally must necessarily
// make yarn form significant in order to avoid data loss in atomization.)
//
// FindRow() can lazily create an index on attribute inColumn for all rows
// with that attribute in row space scope inRowScope, so that subsequent
// calls to FindRow() will perform faster. Such an index might or might
// not be persistent (but this seems desirable if it is cheap to do so).
// Note that lazy index creation in readonly DBs is not very feasible.
//
// This FindRow() interface assumes that attribute inColumn is effectively
// an alternative means of unique identification for a row in a rowspace,
// so correct behavior is only guaranteed when no duplicates for this col
// appear in the given set of rows. (If more than one row has the same cell
// value in this column, no more than one will be found; and cutting one of
// two duplicate rows can cause the index to assume no other such row lives
// in the row space, so future calls return nil for negative search results
// even though some duplicate row might still live within the rowspace.)
//
// In other words, the FindRow() implementation is allowed to assume simple
// hash tables mapping unique column keys to associated row values will be
// sufficient, where any duplication is not recorded because only one copy
// of a given key need be remembered. Implementors are not required to sort
// all rows by the specified column.
{
nsresult outErr = NS_OK;
nsIMdbRow* outRow = 0;
mdbOid rowOid;
rowOid.mOid_Scope = 0;
rowOid.mOid_Id = (mdb_id)-1;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = FindRow(ev, inRowScope, inColumn, inTargetCellValue);
if (row && ev->Good()) {
rowOid = row->mRow_Oid;
if (acqRow) outRow = row->AcquireRowHandle(ev, this);
}
outErr = ev->AsErr();
}
if (acqRow) *acqRow = outRow;
if (outRowOid) *outRowOid = rowOid;
return outErr;
}
// } ----- end row methods -----
// { ----- begin table methods -----
NS_IMETHODIMP
morkStore::HasTable( // supports a table with the specified oid?
nsIMdbEnv* mev, // context
const mdbOid* inOid, // hypothetical table oid
mdb_bool* outHasTable) // whether GetTable() might succeed
{
nsresult outErr = NS_OK;
mork_bool hasTable = morkBool_kFalse;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = GetTable(ev, inOid);
if (table) hasTable = morkBool_kTrue;
outErr = ev->AsErr();
}
if (outHasTable) *outHasTable = hasTable;
return outErr;
}
NS_IMETHODIMP
morkStore::GetTable( // access one table with specific oid
nsIMdbEnv* mev, // context
const mdbOid* inOid, // hypothetical table oid
nsIMdbTable** acqTable) // acquire specific table (or null)
{
nsresult outErr = NS_OK;
nsIMdbTable* outTable = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = GetTable(ev, inOid);
if (table && ev->Good()) outTable = table->AcquireTableHandle(ev);
outErr = ev->AsErr();
}
if (acqTable) *acqTable = outTable;
return outErr;
}
NS_IMETHODIMP
morkStore::HasTableKind( // supports a table of the specified type?
nsIMdbEnv* mev, // context
mdb_scope inRowScope, // rid scope for row ids
mdb_kind inTableKind, // the type of table to access
mdb_count* outTableCount, // current number of such tables
mdb_bool* outSupportsTable) // whether GetTableKind() might succeed
{
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
*outSupportsTable =
HasTableKind(ev, inRowScope, inTableKind, outTableCount);
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::GetTableKind( // access one (random) table of specific type
nsIMdbEnv* mev, // context
mdb_scope inRowScope, // row scope for row ids
mdb_kind inTableKind, // the type of table to access
mdb_count* outTableCount, // current number of such tables
mdb_bool* outMustBeUnique, // whether port can hold only one of these
nsIMdbTable** acqTable) // acquire scoped collection of rows
{
nsresult outErr = NS_OK;
nsIMdbTable* outTable = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = GetTableKind(ev, inRowScope, inTableKind, outTableCount,
outMustBeUnique);
if (table && ev->Good()) outTable = table->AcquireTableHandle(ev);
outErr = ev->AsErr();
}
if (acqTable) *acqTable = outTable;
return outErr;
}
NS_IMETHODIMP
morkStore::GetPortTableCursor( // get cursor for all tables of specific type
nsIMdbEnv* mev, // context
mdb_scope inRowScope, // row scope for row ids
mdb_kind inTableKind, // the type of table to access
nsIMdbPortTableCursor** acqCursor) // all such tables in the port
{
nsresult outErr = NS_OK;
nsIMdbPortTableCursor* outCursor = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkPortTableCursor* cursor =
GetPortTableCursor(ev, inRowScope, inTableKind);
if (cursor && ev->Good()) outCursor = cursor;
outErr = ev->AsErr();
}
if (acqCursor) *acqCursor = outCursor;
return outErr;
}
// } ----- end table methods -----
// { ----- begin commit methods -----
NS_IMETHODIMP
morkStore::ShouldCompress( // store wastes at least inPercentWaste?
nsIMdbEnv* mev, // context
mdb_percent inPercentWaste, // 0..100 percent file size waste threshold
mdb_percent* outActualWaste, // 0..100 percent of file actually wasted
mdb_bool* outShould) // true when about inPercentWaste% is wasted
{
mdb_percent actualWaste = 0;
mdb_bool shouldCompress = morkBool_kFalse;
nsresult outErr = NS_OK;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
actualWaste = PercentOfStoreWasted(ev);
if (inPercentWaste > 100) inPercentWaste = 100;
shouldCompress = (actualWaste >= inPercentWaste);
outErr = ev->AsErr();
}
if (outActualWaste) *outActualWaste = actualWaste;
if (outShould) *outShould = shouldCompress;
return outErr;
}
// } ===== end nsIMdbPort methods =====
NS_IMETHODIMP
morkStore::NewTable( // make one new table of specific type
nsIMdbEnv* mev, // context
mdb_scope inRowScope, // row scope for row ids
mdb_kind inTableKind, // the type of table to access
mdb_bool inMustBeUnique, // whether store can hold only one of these
const mdbOid* inOptionalMetaRowOid, // can be nil to avoid specifying
nsIMdbTable** acqTable) // acquire scoped collection of rows
{
nsresult outErr = NS_OK;
nsIMdbTable* outTable = 0;
morkEnv* ev = this->CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = NewTable(ev, inRowScope, inTableKind, inMustBeUnique,
inOptionalMetaRowOid);
if (table && ev->Good()) outTable = table->AcquireTableHandle(ev);
outErr = ev->AsErr();
}
if (acqTable) *acqTable = outTable;
return outErr;
}
NS_IMETHODIMP
morkStore::NewTableWithOid( // make one new table of specific type
nsIMdbEnv* mev, // context
const mdbOid* inOid, // caller assigned oid
mdb_kind inTableKind, // the type of table to access
mdb_bool inMustBeUnique, // whether store can hold only one of these
const mdbOid* inOptionalMetaRowOid, // can be nil to avoid specifying
nsIMdbTable** acqTable) // acquire scoped collection of rows
{
nsresult outErr = NS_OK;
nsIMdbTable* outTable = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkTable* table = OidToTable(ev, inOid, inOptionalMetaRowOid);
if (table && ev->Good()) {
table->mTable_Kind = inTableKind;
if (inMustBeUnique) table->SetTableUnique();
outTable = table->AcquireTableHandle(ev);
}
outErr = ev->AsErr();
}
if (acqTable) *acqTable = outTable;
return outErr;
}
// } ----- end table methods -----
// { ----- begin row scope methods -----
NS_IMETHODIMP
morkStore::RowScopeHasAssignedIds(
nsIMdbEnv* mev,
mdb_scope inRowScope, // row scope for row ids
mdb_bool* outCallerAssigned, // nonzero if caller assigned specified
mdb_bool* outStoreAssigned) // nonzero if store db assigned specified
{
NS_ASSERTION(false, " not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
morkStore::SetCallerAssignedIds(
nsIMdbEnv* mev,
mdb_scope inRowScope, // row scope for row ids
mdb_bool* outCallerAssigned, // nonzero if caller assigned specified
mdb_bool* outStoreAssigned) // nonzero if store db assigned specified
{
NS_ASSERTION(false, " not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
morkStore::SetStoreAssignedIds(
nsIMdbEnv* mev,
mdb_scope inRowScope, // row scope for row ids
mdb_bool* outCallerAssigned, // nonzero if caller assigned specified
mdb_bool* outStoreAssigned) // nonzero if store db assigned specified
{
NS_ASSERTION(false, " not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
// } ----- end row scope methods -----
// { ----- begin row methods -----
NS_IMETHODIMP
morkStore::NewRowWithOid(nsIMdbEnv* mev, // new row w/ caller assigned oid
const mdbOid* inOid, // caller assigned oid
nsIMdbRow** acqRow) // create new row
{
nsresult outErr = NS_OK;
nsIMdbRow* outRow = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = NewRowWithOid(ev, inOid);
if (row && ev->Good()) outRow = row->AcquireRowHandle(ev, this);
outErr = ev->AsErr();
}
if (acqRow) *acqRow = outRow;
return outErr;
}
NS_IMETHODIMP
morkStore::NewRow(nsIMdbEnv* mev, // new row with db assigned oid
mdb_scope inRowScope, // row scope for row ids
nsIMdbRow** acqRow) // create new row
// Note this row must be added to some table or cell child before the
// store is closed in order to make this row persist across sessions.
{
nsresult outErr = NS_OK;
nsIMdbRow* outRow = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkRow* row = NewRow(ev, inRowScope);
if (row && ev->Good()) outRow = row->AcquireRowHandle(ev, this);
outErr = ev->AsErr();
}
if (acqRow) *acqRow = outRow;
return outErr;
}
// } ----- end row methods -----
// { ----- begin import/export methods -----
NS_IMETHODIMP
morkStore::ImportContent( // import content from port
nsIMdbEnv* mev, // context
mdb_scope inRowScope, // scope for rows (or zero for all?)
nsIMdbPort* ioPort, // the port with content to add to store
nsIMdbThumb** acqThumb) // acquire thumb for incremental import
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the import will be finished.
{
NS_ASSERTION(false, " not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
morkStore::ImportFile( // import content from port
nsIMdbEnv* mev, // context
nsIMdbFile* ioFile, // the file with content to add to store
nsIMdbThumb** acqThumb) // acquire thumb for incremental import
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the import will be finished.
{
NS_ASSERTION(false, " not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
}
// } ----- end import/export methods -----
// { ----- begin hinting methods -----
NS_IMETHODIMP
morkStore::ShareAtomColumnsHint( // advise re shared col content atomizing
nsIMdbEnv* mev, // context
mdb_scope inScopeHint, // zero, or suggested shared namespace
const mdbColumnSet* inColumnSet) // cols desired tokenized together
{
MORK_USED_2(inColumnSet, inScopeHint);
nsresult outErr = NS_OK;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing for a hint method
outErr = ev->AsErr();
}
return outErr;
}
NS_IMETHODIMP
morkStore::AvoidAtomColumnsHint( // advise col w/ poor atomizing prospects
nsIMdbEnv* mev, // context
const mdbColumnSet* inColumnSet) // cols with poor atomizing prospects
{
MORK_USED_1(inColumnSet);
nsresult outErr = NS_OK;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
// ev->StubMethodOnlyError(); // okay to do nothing for a hint method
outErr = ev->AsErr();
}
return outErr;
}
// } ----- end hinting methods -----
// { ----- begin commit methods -----
NS_IMETHODIMP
morkStore::LargeCommit( // save important changes if at all possible
nsIMdbEnv* mev, // context
nsIMdbThumb** acqThumb) // acquire thumb for incremental commit
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the commit will be finished. Note the store is effectively write
// locked until commit is finished or canceled through the thumb instance.
// Until the commit is done, the store will report it has readonly status.
{
nsresult outErr = NS_OK;
nsIMdbThumb* outThumb = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkThumb* thumb = 0;
// morkFile* file = store->mStore_File;
if (DoPreferLargeOverCompressCommit(ev)) {
thumb = morkThumb::Make_LargeCommit(ev, mPort_Heap, this);
} else {
mork_bool doCollect = morkBool_kFalse;
thumb = morkThumb::Make_CompressCommit(ev, mPort_Heap, this, doCollect);
}
if (thumb) {
outThumb = thumb;
thumb->AddRef();
}
outErr = ev->AsErr();
}
if (acqThumb) *acqThumb = outThumb;
return outErr;
}
NS_IMETHODIMP
morkStore::SessionCommit( // save all changes if large commits delayed
nsIMdbEnv* mev, // context
nsIMdbThumb** acqThumb) // acquire thumb for incremental commit
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the commit will be finished. Note the store is effectively write
// locked until commit is finished or canceled through the thumb instance.
// Until the commit is done, the store will report it has readonly status.
{
nsresult outErr = NS_OK;
nsIMdbThumb* outThumb = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
morkThumb* thumb = 0;
if (DoPreferLargeOverCompressCommit(ev)) {
thumb = morkThumb::Make_LargeCommit(ev, mPort_Heap, this);
} else {
mork_bool doCollect = morkBool_kFalse;
thumb = morkThumb::Make_CompressCommit(ev, mPort_Heap, this, doCollect);
}
if (thumb) {
outThumb = thumb;
thumb->AddRef();
}
outErr = ev->AsErr();
}
if (acqThumb) *acqThumb = outThumb;
return outErr;
}
NS_IMETHODIMP
morkStore::CompressCommit( // commit and make db smaller if possible
nsIMdbEnv* mev, // context
nsIMdbThumb** acqThumb) // acquire thumb for incremental commit
// Call nsIMdbThumb::DoMore() until done, or until the thumb is broken, and
// then the commit will be finished. Note the store is effectively write
// locked until commit is finished or canceled through the thumb instance.
// Until the commit is done, the store will report it has readonly status.
{
nsresult outErr = NS_OK;
nsIMdbThumb* outThumb = 0;
morkEnv* ev = CanUseStore(mev, /*inMutable*/ morkBool_kFalse, &outErr);
if (ev) {
mork_bool doCollect = morkBool_kFalse;
morkThumb* thumb =
morkThumb::Make_CompressCommit(ev, mPort_Heap, this, doCollect);
if (thumb) {
outThumb = thumb;
thumb->AddRef();
mStore_CanWriteIncremental = morkBool_kTrue;
}
outErr = ev->AsErr();
}
if (acqThumb) *acqThumb = outThumb;
return outErr;
}
// } ----- end commit methods -----
// } ===== end nsIMdbStore methods =====
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789