OOFILE  1.9
oof2.cpp
Go to the documentation of this file.
1 // COPYRIGHT 1994-1997 A.D. Software, All rights reserved
2 
3 // backend parent layer of OOFILE database
4 
5 #include "oofpch_c.h" // for precompilation of core files
6 
7 #ifndef H_OOFIOS
8  #include "oofios.h"
9 #endif
10 #ifndef H_OOF2
11  #include "oof2.h"
12 #endif
13 #ifdef OOF_MEM_DEBUG_LAST_INCLUDE
14  #include OOF_MEM_DEBUG_LAST_INCLUDE
15 #endif
16 
17 #ifndef OOF_NO_STDLIB
18  #ifndef std
19  using namespace std;
20  #endif
21 #endif
22 
23 // -------------------------------------------------------
24 // s t a t i c v a r s
25 // -------------------------------------------------------
28 
29 // -------------------------------------------------------
30 // O O F _ D u m m y S t r i n g
31 // -------------------------------------------------------
32 OOF_DummyString::OOF_DummyString(const char* dummyPrefix) :
33  mSuffix(0)
34 {
35  if (dummyPrefix)
36  sStrings.SetPrefix(dummyPrefix);
37 }
38 
39 
40 const OOF_String&
42 {
43  const OOF_String& ret = sStrings.Dummy(mSuffix);
44  mSuffix++;
45  return ret;
46 }
47 
48 
49 void
51 {
52  sStrings.ReleaseAllStorage();
53 }
54 
55 
56 // -------------------------------------------------------
57 // O O F _ D u m m y S t o r a g e
58 // -------------------------------------------------------
59 OOF_DummyStorage::OOF_DummyStorage() :
60  mPrefix("dummy")
61 {
62 }
63 
64 
66 {
67  DeleteAllStrings();
68 }
69 
70 
71 void
72 OOF_DummyStorage::DeleteAllStrings()
73 {
74  const unsigned long numStr = mStringCache.count();
75  for (unsigned int i=0; i<numStr; i++) {
76  OOF_String* theStr = (OOF_String*) mStringCache.value(i);
77  delete theStr;
78  mStringCache[i] = 0;
79  }
80  mStringCache.deleteAllCells(false); // just reset counter
81 }
82 
83 
87 void
88 OOF_DummyStorage::ReleaseAllStorage()
89 {
90  DeleteAllStrings();
91  mStringCache.deleteAllCells(true);
92 }
93 
94 
95 void
96 OOF_DummyStorage::SetPrefix(const OOF_String& newPrefix)
97 {
98  if (mPrefix!=newPrefix) // regenerate all the strings!
99  DeleteAllStrings(); // but only do half the job
100  // we don't have to recreate them until someone needs them
101 }
102 
103 
104 const OOF_String&
105 OOF_DummyStorage::Dummy(unsigned long suffix)
106 {
107 // create a dummy entry but hopefully there's one in the stringCache
108  OOF_String* ret = (OOF_String*) mStringCache[suffix];
109  if (!ret) {
110  char buf[80];
111  sprintf(buf, "%lu", suffix); // concatenate
112  ret = new OOF_String(mPrefix, buf);
113  mStringCache[suffix] = (unsigned long)ret;
114  }
115  return *ret;
116 }
117 
118 
119 
120 // -------------------------------------------------------
121 // O O F _ S h a r e d A r r a y
122 // -------------------------------------------------------
123 OOF_SharedArray::OOF_SharedArray(unsigned long defaultValue, unsigned long numSlots, unsigned int expandBySlots) :
124  OOF_ExpandableLongArray(defaultValue, numSlots, expandBySlots)
125  {}
126 
127 
128 // -------------------------------------------------------
129 // O O F _ t a b l e B a c k e n d
130 // -------------------------------------------------------
132  mFields(theTable->mFields),
133  mTable(theTable),
134  mDirty(false),
135  mHasDefaultCalculators(false),
136  mHasStoredCalculators(false)
137 {
138 }
139 
140 
142  mFields(newTable->mFields),
143  mTable(newTable),
144  mDirty(false),
145  mHasDefaultCalculators(rhs.mHasDefaultCalculators),
146  mHasStoredCalculators(rhs.mHasStoredCalculators)
147 {}
148 
149 
151 {
152  // clear ref pointers for lint
153  mTable = 0;
154 }
155 
156 
157 void
159 {
160 // empty default method
161 }
162 
163 
164 // -------------------------------------------------------
165 // O O F _ D i c t r e p
166 // -------------------------------------------------------
167 void
168 OOF_DictRep::Append(OOF_bitPointer aBit) {
169  (*this)[mNextFreeEntry] = aBit;
170 }
171 
172 
174 OOF_DictRep::Pop()
175 {
176  OOF_bitPointer ret = 0;
177  if (mNextFreeEntry>0) {
178  mNextFreeEntry--;
179  assert(mBits);
180  ret = mBits[mNextFreeEntry];
181  mBits[mNextFreeEntry] = 0;
182  }
183  return ret;
184 }
185 
186 
187 void
188 OOF_DictRep::Reset()
189 {
190  mNextFreeEntry=0;
191 }
192 
193 
194 OOF_DictRep::OOF_DictRep(unsigned int numSlots, unsigned int expandBySlots) :
195  mBits(0),
196  mExpansionChunk(expandBySlots),
197  mNextFreeEntry(0),
198  mNumSlots(0)
199 {
200  if (mExpansionChunk<1)
201  mExpansionChunk = 1;
202  if (numSlots)
203  {
204  mNumSlots = ((numSlots-1) / expandBySlots + 1) * expandBySlots;
205  mBits = new OOF_bitPointer[mNumSlots];
206  assert(mBits);
207  }
208 }
209 
210 
211 OOF_DictRep::OOF_DictRep(const OOF_DictRep* rhs) :
212  mBits(0),
213  mExpansionChunk(rhs->mExpansionChunk),
214  mNextFreeEntry(rhs->mNextFreeEntry),
215  mNumSlots(rhs->mNumSlots)
216 {
217  if (mNumSlots)
218  {
219  mBits = new OOF_bitPointer[mNumSlots];
220  assert(mBits);
221  for (unsigned long i=0; i<mNumSlots; i++)
222  mBits[i] = rhs->mBits[i];
225 #endif
226  }
227 }
228 
229 
230 OOF_DictRep::~OOF_DictRep()
231 {
232  if (mNumSlots)
233  delete[] mBits;
234 }
235 
236 
238 OOF_DictRep::operator[](unsigned int index)
239 {
240  assert(mNextFreeEntry <= mNumSlots);
241 #ifdef OOF_MEM_DEBUG_FORCE_POOL_CHECK
243 #endif
244 #ifdef OOF_DEBUG
245  if (index > mNumSlots) {
246  dbConnect::raise("OOF_DictRep::operator[] skipped a cell - suspect index", false /* don't exit*/);
247  }
248 #endif
249  if (index >= mNumSlots)
250  ExpandToInclude(index);
251  if (index >= mNextFreeEntry)
252  mNextFreeEntry = index+1;
253  return mBits[index];
254 }
255 
256 
258 OOF_DictRep::operator[](const char* name)
259 {
260  return lookupByAttribute(name);
261 }
262 
263 
265 OOF_DictRep::lookupByAttribute(const char* attributeValue, const char* /*attributeType*/)
266 {
267 // NOT YET IMPLEMENTED - attributeType currently ignored
268 // NOT YET IMPLEMENTED - future dictionaries would stored hashed names
269 // for rapid lookup, as well as storing other attributes or at least being
270 // able to invoke a virtual hasAttribute(value, type) on the mBits
271 
272  const unsigned int numEntries = mNextFreeEntry;
273  for (unsigned long i=0; i<numEntries; i++) {
274  OOF_bitPointer& theBit = mBits[i];
275  if (theBit->name()==attributeValue)
276  return theBit;
277  }
279 }
280 
281 
283 OOF_DictRep::value(unsigned int index) const
284 {
285  assert(index < mNextFreeEntry);
286  assert(mNextFreeEntry <= mNumSlots);
287  return mBits[index];
288 }
289 
290 
291 void
292 OOF_DictRep::ExpandToInclude(unsigned int indexToCover)
293 {
294  unsigned int newSize = (indexToCover / mExpansionChunk + 1) * mExpansionChunk;
295  OOF_bitPointer *oldBits = mBits;
296  mBits = new OOF_bitPointer[newSize];
297 // NOT YET IMPLEMENTED - need error handling here
298 
299  assert(mBits);
300 #ifdef OOF_MEM_DEBUG_FORCE_POOL_CHECK
302 #endif
303  if (oldBits) {
304  for (unsigned long i=0; i<mNextFreeEntry; i++)
305  mBits[i] = oldBits[i];
306  delete[] oldBits;
307  }
308 #ifdef OOF_MEM_DEBUG_FORCE_POOL_CHECK
310 #endif
311  for (unsigned long i=mNextFreeEntry; i<newSize; i++)
312  mBits[i] = 0;
313 #ifdef OOF_MEM_DEBUG_FORCE_POOL_CHECK
315 #endif
316  mNumSlots = newSize;
317 }
318 
319 
320 
321 // -------------------------------------------------------
322 // O O F _ D i c t i o n a r y
323 // -------------------------------------------------------
325  mOwnsContents(false)
326 {
328 }
329 
330 
332  mOwnsContents(false)
333 {
334  mRep = new OOF_DictRep(rep);
335 }
336 
337 
338 OOF_Dictionary::OOF_Dictionary(unsigned int numSlots) :
339  mOwnsContents(false)
340 {
341  mRep = new OOF_DictRep(numSlots, kDefExpansionChunk);
342 }
343 
344 
345 OOF_Dictionary::OOF_Dictionary(unsigned int numSlots, unsigned int expansionChunk, bool inOwnsContents) :
346  mOwnsContents(inOwnsContents)
347 {
348 // only this particular ctor allows you to pass in inOwnsContents because of ambiguity problems
349 // with others having the bool param confused with a different ctor's int params
350  mRep = new OOF_DictRep(numSlots, expansionChunk);
351 }
352 
353 
355  mRep(rhs.mRep),
356  mOwnsContents(rhs.mOwnsContents)
357 {
358  mRep->mReferences++;
359 }
360 
361 
362 
364 {
365  if (--mRep->mReferences<=0) {
366  if (mOwnsContents)
367  deleteAll();
368  delete mRep;
369  }
370 }
371 
372 
375 {
376  if ((this == &rhs) || (mRep == rhs.mRep))
377  return *this;
378 
379  if (--mRep->mReferences<=0)
380  delete mRep;
381 
382  mRep = rhs.mRep;
383  mRep->mReferences++;
384  return *this;
385 }
386 
387 
390 {
391  OOF_Dictionary ret(mRep);
392  return ret;
393 }
394 
395 
396 unsigned int
398 {
399  unsigned int ret=0;
400  unsigned int theCount = count();
401  for (unsigned int i=0; i<theCount; i++) {
402  OOF_PublicBase* entry = mRep->operator[](i);
403  assert(entry); // looping known entries!
404  if (EntryMatchesVisibility(entry, wantVisible))
405  ret++;
406  }
407  return ret;
408 }
409 
414 bool
415 OOF_Dictionary::moreVisible(bool wantVisible)
416 {
417  if (!more())
418  return false;
419  OOF_PublicBase* entry=0;
420  while (more()) {
421  OOF_PublicBase* entry = operator()();
422  assert(entry); // looping known entries!
423  if (EntryMatchesVisibility(entry, wantVisible))
424  return true;
425  next();
426  }
427  return false; // no matches
428 //ASD suspected bug 2003-01-26 return (EntryMatchesVisibility(entry, wantVisible));
429 }
430 
431 
432 void
434 {
435  const unsigned int numEntries = count();
436  for (unsigned int i=0; i<numEntries; i++) {
437  OOF_bitPointer toDel = item(i);
438  delete toDel;
439  next();
440  }
441  mRep->mNextFreeEntry = 0;
442 }
443 
444 
445 void
446 OOF_Dictionary::describe(ostream& os) const
447 {
448  unsigned int numEntries = count();
449  for (unsigned int i=0; i<numEntries; i++) {
450  (value(i))->describe(os);
451  }
452  os << endl;
453 }
454 
455 
456 void
457 OOF_Dictionary::describeVisible(ostream& os, bool wantVisible) const
458 {
459  unsigned int numEntries = count();
460  for (unsigned int i=0; i<numEntries; i++) {
461  OOF_bitPointer entry = value(i);
462  if (EntryMatchesVisibility(entry, wantVisible))
463  entry->describe(os);
464  }
465  os << endl;
466 }
467 
468 
469 bool
471 {
472  if (mRep==rhs.mRep)
473  return true; // trivial case of comparing aliases
474 
475  if (count() != rhs.count())
476  return false;
477 
478  unsigned int numEntries = count();
479  for (unsigned int i=0; i<numEntries; i++)
480  if (operator[](i) != rhs.operator[](i))
481  return false;
482 
483  return true;
484 }
485 
486 
487 // -------------------------------------------------------
488 // O O F _ I n d e x O p t i o n s
489 // -------------------------------------------------------
490 ostream&
491 operator<<(ostream& os, OOF_IndexOptions opt)
492 {
493  switch (opt) {
494  case (kNotIndexed) :
495  os << "not indexed";
496  break;
497 
498  case (kIndexed) :
499  os << "indexed, allowing dups & ignoring case";
500  break;
501 
502  case (kIndexNoDups) :
503  os << "indexed, no dups & ignoring case";
504  break;
505 
506  case (kIndexCaseSensitive) :
507  os << "indexed, allowing dups but case-sensitive";
508  break;
509 
511  os << "indexed, no dups & ignoring case, compressing padding";
512  break;
513 
515  os << "indexed, no dups & ignoring case, compressing front";
516  break;
517 
518  case (kIndexCompressNoDups) :
519  os << "indexed, no dups & ignoring case, compress front & padding";
520  break;
521 
522  case (kIndexCompress) :
523  os << "indexed, ignoring case, compress front & padding";
524  break;
525 
526  case (kIndexCompressPadding) :
527  os << "indexed, ignoring case, compressing padding";
528  break;
529 
530  case (kIndexCompressLeading) :
531  os << "indexed, ignoring case, compressing front";
532  break;
533 
534  case (kIndexNoNulls) :
535  os << "indexed, ignoring case, no nulls";
536  break;
537 
538  case (kIndexNoDupsNoNulls) :
539  os << "indexed, ignoring case, no dups no nulls";
540  break;
541 
542  case (kIndexCompressNoNulls) :
543  os << "indexed, ignoring case, no nulls, compressing front & padding";
544  break;
545 
547  os << "indexed, ignoring case, no nulls, no dups, compressing front & padding";
548  break;
549 
551  os << "indexed, ignoring case, no nulls, no dups, compressing front";
552  break;
553 
555  os << "indexed, ignoring case, no nulls, no dups, compressing padding";
556  break;
557 
558  }
559  return os;
560 }
561 
562 
563 
564 
565 // -------------------------------------------------------
566 // d b S e l e c t i o n
567 // -------------------------------------------------------
569  mSelection(0),
570  mReferences(0)
571 {
572 }
573 
574 
576 {
577  mSelection = sel->clone();
578  mReferences = new unsigned long(1);
579 }
580 
581 
583 {
584  DeleteContents();
585 }
586 
587 
588 void
589 dbSelection::DeleteContents()
590 {
591  if (mReferences) {
592  assert(mSelection);
593  if (*mReferences<=1) {
594  delete mSelection;
595  delete mReferences;
596  }
597  else
598  --*mReferences;
599  }
600 }
601 
602 
604  mSelection(rhs.mSelection),
605  mReferences(rhs.mReferences)
606 {
607  if (mReferences)
608  ++*mReferences;
609 }
610 
611 
614 {
615  if (mReferences) { // not just a blank sel that's never been inited
616  assert(prototypicalTable() == rhs.prototypicalTable()); // can't assign from different source!
617  DeleteContents();
618  }
619  mSelection = rhs.mSelection;
620  mReferences = rhs.mReferences;
621  ++*mReferences;
622  return *this;
623 }
624 
625 
628 {
629  *this = rhs.currentSelection();
630  return *this;
631 }
632 
633 
634 void
636 {
637  if (mSelection)
638  mSelection->intersection_with(rhs.mSelection);
639 }
640 
641 
642 void
644 {
645  if (mSelection)
647 }
648 
649 
650 void
652 {
653  if (mSelection)
654  mSelection->intersection_with(offset);
655 }
656 
657 
658 void
660 {
661  if (mSelection)
662  mSelection->invert();
663 }
664 
665 
666 
667 void
669 {
670  if (mSelection)
672  else
673  *this = rhs;
674 }
675 
676 
677 void
679 {
680  if (mSelection)
681  mSelection->union_with_no_overlap(rhs.mSelection);
682  else
683  *this = rhs;
684 }
685 
686 
687 void
689 {
690  if (mSelection)
692  else
693  *this = rhs;
694 }
695 
696 
697 void
699 {
700  if (mSelection)
701  mSelection->union_with(rhs.mSelection);
702  else
703  *this = rhs;
704 }
705 
706 
707 void
709 {
710  assert (mSelection); // we don't know how to construct a selection from just an oid!, we just own an abstract pointer
711  mSelection->union_with(offset);
712 }
713 
714 
715 // WARNING as an inline these routines taking dbSelection& rhs had major problems
716 // with Visual C++ 4.1, jumping into assert.c whilst processing the arguments
717 void
719 {
720  if (mSelection)
721  mSelection->difference_with(rhs.mSelection);
722 }
723 
724 
725 void
727 {
728  if (mSelection)
729  mSelection->difference_with(rhs.currentSelection().mSelection);
730 }
731 
732 
733 bool
735 {
736  bool ret;
737  if (mSelection)
738  ret = mSelection->isEmpty();
739  else
740  ret = true;
741  return ret;
742 }
743 
744 
745 bool
747 {
748  bool ret;
749  if (mSelection)
750  ret = mSelection->isAllRecs();
751  else
752  ret = false; // assume empty selection means no, although in strict terms it could be
753  return ret;
754 }
755 
756 
757 bool
759 {
760  bool ret;
761  if (mSelection)
762  ret = mSelection->contains(theOID);
763  else
764  ret = false;
765  return ret;
766 }
767 
768 
769 unsigned long
771 {
772  unsigned long ret;
773  if (mReferences) { // has been inited
774  assert(mSelection);
775  if (mSelection->isAllRecs() )
776  ret = prototypicalTable()->countAll();
777  else
778  ret = mSelection->count();
779  }
780  else
781  ret = 0;
782 
783  return ret;
784 }
785 
786 
787 // -------------------------------------------------------
788 // s t S a v e S e l e c t i o n
789 // -------------------------------------------------------
791  mTable(inTable),
792  mSavedSelection(mTable->currentSelection())
793 {
794 }
795 
797  mTable(&inTable),
798  mSavedSelection(mTable->currentSelection())
799 {
800 }
801 
802 
804 {
806 }
807 
808 
809 // -------------------------------------------------------
810 // s t I g n o r e D u p l i c a t e R e c o r d s
811 // -------------------------------------------------------
813  mTable(inTable)
814 {
816 }
817 
819  mTable(&inTable)
820 {
822 }
823 
824 
826 {
828 }
829 
830 
831 // -------------------------------------------------------
832 // s t S a v e S e l e c t i o n A n d S u p p r e s s S o r t
833 // -------------------------------------------------------
835  stSaveSelection(inTable)
836 {
838 }
839 
840 
842 {
844 }
845 
846 
847 // -------------------------------------------------------
848 // s t S u p p r e s s S o r t
849 // -------------------------------------------------------
851  mTable(inTable)
852 {
853  mTable->suspendSorting();
854 }
855 
856 
858 {
859  mTable->resumeSorting();
860 }
static OOF_DummyStorage sStrings
Definition: oof2.h:98
dbTable * mTable
Definition: oof1.h:399
OOF_tableBackend(dbTable *)
Definition: oof2.cpp:131
Definition: oof1.h:236
static void raise(std::ostream &, bool terminateAfterMsg=true)
virtual void deleteStorage()
Definition: oof2.cpp:158
void union_with(const dbSelection &)
Definition: oof2.cpp:698
dbSelection & operator=(const dbSelection &)
Definition: oof2.cpp:613
void intersection_with(const dbSelection &)
Definition: oof2.cpp:635
precompilation header.
virtual OOF_Selection * clone() const =0
Tries to hide the different platforms and version issues with standard IO.
void noticeDuplicateRecords()
Definition: oof1.h:1830
void resumeSorting()
Definition: oof1.cpp:2508
bool allObjectsMatch(OOF_Dictionary &)
Definition: oof2.cpp:470
unsigned long count() const
Definition: oof2.cpp:770
OOF_bitPointer & item(unsigned int index)
Definition: oof1.h:1587
Envelope class to contain an abstract selection apart from its dbTable.
Definition: oof1.h:316
bool moreVisible(bool wantVisible=true)
Definition: oof2.cpp:415
virtual ~stSaveSelection()
Definition: oof2.cpp:803
~stSuspendSort()
Definition: oof2.cpp:857
virtual void describeVisible(std::ostream &, bool wantVisible) const
Definition: oof2.cpp:457
abstract base for public interface to selections.
Definition: oof2.h:107
OOF_SharedArray(unsigned long defaultValue=0, unsigned long numSlots=0, unsigned int expandBySlots=4)
Definition: oof2.cpp:123
void deleteAll()
Definition: oof2.cpp:433
unsigned long count() const
Definition: oofarray.h:126
stIgnoreDuplicateRecords(dbTable *)
Definition: oof2.cpp:812
OOF_DummyString(const char *dummyPrefix=0)
Definition: oof2.cpp:32
unsigned long mSuffix
Definition: oof2.h:97
void union_with_no_overlap(const dbSelection &)
Definition: oof2.cpp:678
bool isEmpty() const
Definition: oof2.cpp:734
~OOF_DummyStorage()
Definition: oof2.cpp:65
OOF_bitPointer value(unsigned int index) const
Definition: oof1.h:1594
unsigned long countAll() const
Count records in database regardless of current selection.
Definition: oof1.h:2029
virtual void union_with_no_overlap(const OOF_Selection *)=0
dbTable * mTable
Definition: oof1.h:416
bool contains(oidT) const
Definition: oof2.cpp:758
virtual void union_with(const OOF_Selection *)=0
~dbSelection()
Definition: oof2.cpp:582
void deleteAllCells(bool alwaysDeleteStorage=false)
Effectively delete cells by resetting mNextFreeEntry cursor.
Definition: oofarray.cpp:219
void ignoreDuplicateRecords()
Definition: oof1.h:1837
virtual void invert()=0
virtual bool isAllRecs() const =0
virtual unsigned long count() const =0
virtual ~OOF_tableBackend()
Definition: oof2.cpp:150
unsigned int countVisible(bool wantVisible=true)
Definition: oof2.cpp:397
oofString OOF_String
Definition: oofstr.h:295
unsigned long oidT
type we pass around pretending we have a real OID.
Definition: oof1.h:229
Abstract interface to database backend.
Definition: oof1.h:1047
void invert()
Definition: oof2.cpp:659
unsigned int mReferences
Definition: oof1.h:90
virtual void describe(std::ostream &) const
Definition: oof2.cpp:446
void suspendSorting()
Definition: oof1.cpp:2492
dbSelection currentSelection()
Definition: oof1.cpp:2674
void setSelection(const dbSelection &)
Definition: oof1.cpp:2725
OOF_DictRep * mRep
Definition: oof1.h:213
virtual bool isEmpty() const =0
Base class used to refer to main OOFILE classes and provide base reflective API.
Definition: oof1.h:49
Array of longs which expands automatically as you write to cells.
Definition: oofarray.h:21
Save & restore current database selection on the stack.
Definition: oof1.h:392
OOF_Dictionary clone() const
Definition: oof2.cpp:389
stSaveSelection(dbTable *)
Definition: oof2.cpp:790
void difference_with(const dbSelection &)
Definition: oof2.cpp:718
unsigned int count() const
Definition: oof1.h:1498
virtual oofString name() const
Definition: oof1.cpp:349
Base class for persistent tables.
Definition: oof1.h:452
Portable highly capable string class.
Definition: oofstr.h:101
virtual void describe(std::ostream &) const
Provide human-readable information about object.
Definition: oof1.cpp:342
virtual void difference_with(const OOF_Selection *)=0
virtual ~OOF_Dictionary()
Definition: oof2.cpp:363
const dbTable * prototypicalTable() const
Definition: oof2.h:324
bool EntryMatchesVisibility(const OOF_PublicBase *, bool) const
Definition: oof1.h:1526
OOF_Dictionary()
Definition: oof2.cpp:324
static void releaseAllStorage()
Definition: oof2.cpp:50
bool more() const
Definition: oof1.h:1512
#define OOF_MEM_DEBUG_FORCE_POOL_CHECK
Definition: doxyoof.h:408
static OOF_bitPointer & missingItem()
Definition: oof1.h:1622
OOF_bitPointer & operator()()
Definition: oof1.h:1572
virtual bool contains(oidT) const =0
OOF_IndexOptions
type used to specify index options for dbField's.
Definition: oof1.h:236
bool isAllRecs() const
Definition: oof2.cpp:746
Array of dummy name strings including generator function.
Definition: oof2.h:59
std::ostream & operator<<(std::ostream &, const oofE_Base &)
Representation of ref-counted dictionary.
Definition: oof1.h:121
stSuspendSort(dbTable *)
Definition: oof2.cpp:850
void next()
Definition: oof1.h:1519
const OOF_String & nextDummy()
Definition: oof2.cpp:41
dbTable * mTable
Definition: oof1.h:1234
virtual ~stSaveSelectionAndSuspendSort()
Definition: oof2.cpp:841
bool mOwnsContents
Definition: oof1.h:215
static OOF_bitPointer sMissingItem
Definition: oof1.h:216
dbSelection mSavedSelection
Definition: oof1.h:400
OOF_Dictionary & operator=(const OOF_Dictionary &)
Definition: oof2.cpp:374
stSaveSelectionAndSuspendSort(dbTable *)
Definition: oof2.cpp:834
unsigned long value(unsigned long index) const
Definition: oofarray.cpp:243
virtual void intersection_with(const OOF_Selection *)=0
dbSelection()
Definition: oof2.cpp:568
Provides searchable dictionary of common OOFILE classes like dbTable.
Definition: oof1.h:159