| 1 | // Created on: 2002-04-09 |
| 2 | // Created by: Alexander KARTOMIN (akm) |
| 3 | // Copyright (c) 2002-2012 OPEN CASCADE SAS |
| 4 | // |
| 5 | // The content of this file is subject to the Open CASCADE Technology Public |
| 6 | // License Version 6.5 (the "License"). You may not use the content of this file |
| 7 | // except in compliance with the License. Please obtain a copy of the License |
| 8 | // at http://www.opencascade.org and read it completely before using this file. |
| 9 | // |
| 10 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its |
| 11 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. |
| 12 | // |
| 13 | // The Original Code and all software distributed under the License is |
| 14 | // distributed on an "AS IS" basis, without warranty of any kind, and the |
| 15 | // Initial Developer hereby disclaims all such warranties, including without |
| 16 | // limitation, any warranties of merchantability, fitness for a particular |
| 17 | // purpose or non-infringement. Please see the License for the specific terms |
| 18 | // and conditions governing the rights and limitations under the License. |
| 19 | |
| 20 | #ifndef NCollection_BaseCollection_HeaderFile |
| 21 | #define NCollection_BaseCollection_HeaderFile |
| 22 | |
| 23 | #include <NCollection_IncAllocator.hxx> |
| 24 | #include <NCollection_DefineAlloc.hxx> |
| 25 | |
| 26 | /** |
| 27 | * Purpose: NCollection_BaseCollection is the base abstract class for |
| 28 | * all collection templates of this package. |
| 29 | * The set of collections is similar to that of TCollection. |
| 30 | * Also the methods of classes have mostly the same names for |
| 31 | * easy switch from TCollection <-> NCollection containers. |
| 32 | * |
| 33 | * NCollection is a nocdlpack, thus it is compiled without WOK. |
| 34 | * BaseCollection allows assigning the collections of different |
| 35 | * kinds (the items type being the same) with a few obvious |
| 36 | * exclusions - one can not assign any collection to the map |
| 37 | * having double data (two keys or a key plus value). Only the |
| 38 | * maps of the very same type may be assigned through operator= |
| 39 | * Said maps are: DoubleMap, |
| 40 | * DataMap, |
| 41 | * IndexedDataMap |
| 42 | * |
| 43 | * For the users needing control over the memory usage the |
| 44 | * allocators were added (see NCollection_BaseAllocator header) |
| 45 | * Others may forget it - BaseAllocator is used by default and |
| 46 | * then memory is managed through Standard::Allocate/::Free. |
| 47 | */ |
| 48 | template<class TheItemType> class NCollection_BaseCollection |
| 49 | { |
| 50 | public: |
| 51 | // **************** The interface for iterating over collections |
| 52 | class Iterator |
| 53 | { |
| 54 | public: |
| 55 | //! Query if the end of collection is reached by iterator |
| 56 | virtual Standard_Boolean More(void) const=0; |
| 57 | //! Make a step along the collection |
| 58 | virtual void Next(void)=0; |
| 59 | //! Value inquiry |
| 60 | virtual const TheItemType& Value(void) const=0; |
| 61 | //! Value change access |
| 62 | virtual TheItemType& ChangeValue(void) const=0; |
| 63 | public: |
| 64 | DEFINE_STANDARD_ALLOC |
| 65 | DEFINE_NCOLLECTION_ALLOC |
| 66 | protected: |
| 67 | //! Empty constructor |
| 68 | Iterator (void) {} |
| 69 | //! Virtual destructor is necessary for classes with virtual methods |
| 70 | virtual ~Iterator (void) {} |
| 71 | protected: |
| 72 | //! operator= is prohibited |
| 73 | const Iterator& operator= (const Iterator&); |
| 74 | //! Copy constructor ** |
| 75 | Iterator (const Iterator&) {} |
| 76 | }; // End of nested class Iterator |
| 77 | |
| 78 | public: |
| 79 | // ---------- PUBLIC METHODS ------------ |
| 80 | |
| 81 | //! Common for all collections constructor takes care of theAllocator |
| 82 | NCollection_BaseCollection |
| 83 | (const Handle(NCollection_BaseAllocator)& theAllocator=0L) |
| 84 | { |
| 85 | if (theAllocator.IsNull()) |
| 86 | myAllocator = NCollection_BaseAllocator::CommonBaseAllocator(); |
| 87 | else |
| 88 | myAllocator = theAllocator; |
| 89 | } |
| 90 | |
| 91 | //! Number of items |
| 92 | virtual Standard_Integer Size(void) const = 0; |
| 93 | |
| 94 | //! Virtual assignment |
| 95 | virtual void Assign |
| 96 | (const NCollection_BaseCollection& theOther)=0; |
| 97 | |
| 98 | //! Method to create iterators for base collections |
| 99 | virtual Iterator& CreateIterator(void) const=0; |
| 100 | |
| 101 | //! Destructor - must be implemented to release the memory |
| 102 | virtual ~NCollection_BaseCollection (void) {} |
| 103 | |
| 104 | //! Returns attached allocator |
| 105 | const Handle(NCollection_BaseAllocator)& Allocator() const { return myAllocator; } |
| 106 | |
| 107 | protected: |
| 108 | // --------- PROTECTED METHOD ----------- |
| 109 | const Handle(NCollection_BaseAllocator)& IterAllocator(void) const |
| 110 | { |
| 111 | if (myIterAllocator.IsNull()) |
| 112 | (Handle_NCollection_BaseAllocator&) myIterAllocator = |
| 113 | new NCollection_IncAllocator(64); |
| 114 | return myIterAllocator; |
| 115 | } |
| 116 | |
| 117 | //! Exchange allocators of two collections |
| 118 | void exchangeAllocators (NCollection_BaseCollection& theOther) |
| 119 | { |
| 120 | std::swap (myAllocator, theOther.myAllocator); |
| 121 | std::swap (myIterAllocator, theOther.myIterAllocator); |
| 122 | } |
| 123 | |
| 124 | protected: |
| 125 | // --------- PROTECTED FIELDS ----------- |
| 126 | Handle(NCollection_BaseAllocator) myAllocator; |
| 127 | private: |
| 128 | // ---------- PRIVATE FIELDS ------------ |
| 129 | Handle(NCollection_BaseAllocator) myIterAllocator; |
| 130 | |
| 131 | }; |
| 132 | |
| 133 | #endif |