0022815: Missing delete operator for placement new
[occt.git] / src / TColStd / TColStd_PackedMapOfInteger.hxx
1 // File:      TColStd_PackedMapOfInteger.hxx
2 // Created:   05.11.05 10:43:14
3 // Author:    Alexander GRIGORIEV
4 // Copyright: Open Cascade 2005
5
6
7 #ifndef TColStd_PackedMapOfInteger_HeaderFile
8 #define TColStd_PackedMapOfInteger_HeaderFile
9
10 #include <Standard_DefineAlloc.hxx>
11 #include <TCollection_BasicMap.hxx>
12
13 /**
14  *  Optimized Map of integer values. Each block of 32 integers is stored in
15  *  8 bytes in memory.
16  */
17
18 class TColStd_PackedMapOfInteger : private TCollection_BasicMap
19 {
20  public:
21   // operators new and delete must be defined explicitly 
22   // since inherited ones are not accessible
23   DEFINE_STANDARD_ALLOC
24   
25  public:
26   // ---------- PUBLIC METHODS ----------
27
28   /// Constructor
29   inline  TColStd_PackedMapOfInteger  (const Standard_Integer NbBuckets = 1)
30     : TCollection_BasicMap (NbBuckets, Standard_True),
31       myExtent             (0) {}
32
33   inline TColStd_PackedMapOfInteger&
34                           operator =  (const TColStd_PackedMapOfInteger& Other) 
35   { return Assign(Other); }
36
37   Standard_EXPORT TColStd_PackedMapOfInteger&
38                           Assign        (const TColStd_PackedMapOfInteger&);
39   Standard_EXPORT  void   ReSize        (const Standard_Integer NbBuckets);
40   Standard_EXPORT  void   Clear         ();
41   ~TColStd_PackedMapOfInteger() { Clear(); }
42   Standard_EXPORT  Standard_Boolean
43                           Add           (const Standard_Integer aKey);
44   Standard_EXPORT  Standard_Boolean
45                           Contains      (const Standard_Integer aKey) const;
46   Standard_EXPORT  Standard_Boolean
47                           Remove        (const Standard_Integer aKey);
48
49   inline Standard_Integer NbBuckets     () const
50   { return TCollection_BasicMap::NbBuckets(); }
51
52   inline Standard_Integer Extent        () const
53   { return Standard_Integer (myExtent); }
54
55   inline Standard_Integer IsEmpty       () const
56   { return TCollection_BasicMap::IsEmpty(); }
57
58   inline void             Statistics    (Standard_OStream& outStream) const
59   { TCollection_BasicMap::Statistics (outStream); }
60
61   /**
62    * Query the minimal contained key value.
63    */
64   Standard_EXPORT Standard_Integer GetMinimalMapped () const;
65
66   /**
67    * Query the maximal contained key value.
68    */
69   Standard_EXPORT Standard_Integer GetMaximalMapped () const;
70
71 public:
72   //!@name Boolean operations with maps as sets of integers
73   //!@{
74   
75   /**
76    * Sets this Map to be the result of union (aka addition, fuse, merge, 
77    * boolean OR) operation between two given Maps.
78    * The new Map contains the values that are contained either in the
79    * first map or in the second map or in both.<br>
80    * All previous contents of this Map is cleared. This map (result of the
81    * boolean operation) can also be passed as one of operands.<br>
82    */
83   Standard_EXPORT void Union (const TColStd_PackedMapOfInteger&,
84                               const TColStd_PackedMapOfInteger&);
85
86   /**
87    * Apply to this Map the boolean operation union (aka addition, fuse, merge,
88    * boolean OR) with another (given) Map.
89    * The result contains the values that were previously contained in
90    * this map or contained in the given (operand) map.<br>
91    * This algorithm is similar to method Union().
92    * Returns True if contents of this map is changed.
93    */
94   Standard_EXPORT Standard_Boolean Unite (const TColStd_PackedMapOfInteger&);
95
96   /**
97    * Overloaded operator version of Unite().
98    */
99   TColStd_PackedMapOfInteger& operator |= (const TColStd_PackedMapOfInteger& MM)
100   { Unite(MM); return *this; }
101
102   /**
103    * Sets this Map to be the result of intersection (aka multiplication, common, 
104    * boolean AND) operation between two given Maps.
105    * The new Map contains only the values that are contained in both map
106    * operands.<br>
107    * All previous contents of this Map is cleared. This same map (result of the
108    * boolean operation) can also be used as one of operands.<br>
109    * The order of operands makes no difference; the method minimizes internally
110    * the number of iterations using the smallest map for the loop.
111    */
112   Standard_EXPORT void Intersection (const TColStd_PackedMapOfInteger&,
113                                      const TColStd_PackedMapOfInteger&);
114
115   /**
116    * Apply to this Map the intersection operation (aka multiplication, common, 
117    * boolean AND) with another (given) Map.
118    * The result contains only the values that are contained in both this and
119    * the given maps.<br>
120    * This algorithm is similar to method Intersection().
121    * Returns True if contents of this map is changed.
122    */
123   Standard_EXPORT Standard_Boolean Intersect (const TColStd_PackedMapOfInteger&);
124
125   /**
126    * Overloaded operator version of Intersect().
127    */
128   TColStd_PackedMapOfInteger& operator &= (const TColStd_PackedMapOfInteger& MM)
129   { Intersect(MM); return *this; }
130
131   /**
132    * Sets this Map to be the result of subtraction (aka set-theoretic difference, 
133    * relative complement, exclude, cut, boolean NOT) operation between two given Maps.
134    * The new Map contains only the values that are contained in the first map
135    * operands and not contained in the second one.<br>
136    * All previous contents of this Map is cleared. This map (result of the
137    * boolean operation) can also be used as the first operand.<br>
138    */
139   Standard_EXPORT void Subtraction (const TColStd_PackedMapOfInteger&,
140                                     const TColStd_PackedMapOfInteger&);
141
142   /**
143    * Apply to this Map the subtraction (aka set-theoretic difference, relative 
144    * complement, exclude, cut, boolean NOT) operation with another (given) Map.
145    * The result contains only the values that were previously contained in
146    * this map and not contained in this map.<br>
147    * This algorithm is similar to method Subtract() with two operands.
148    * Returns True if contents of this map is changed.
149    */
150   Standard_EXPORT Standard_Boolean Subtract (const TColStd_PackedMapOfInteger&);
151
152   /**
153    * Overloaded operator version of Subtract().
154    */
155   TColStd_PackedMapOfInteger& operator -= (const TColStd_PackedMapOfInteger& MM)
156   { Subtract(MM); return *this; }
157
158   /**
159    * Sets this Map to be the result of symmetric difference (aka exclusive 
160    * disjunction, boolean XOR) operation between two given Maps.
161    * The new Map contains the values that are contained only in the 
162    * first or the second operand maps but not in both.<br>
163    * All previous contents of this Map is cleared. This map (result of the
164    * boolean operation) can also be used as one of operands.<br>
165    */
166   Standard_EXPORT void Difference (const TColStd_PackedMapOfInteger&,
167                                    const TColStd_PackedMapOfInteger&);
168
169   /**
170    * Apply to this Map the symmetric difference (aka exclusive 
171    * disjunction, boolean XOR) operation with another (given) Map.
172    * The result contains the values that are contained only in this
173    * or the operand map, but not in both.<br>
174    * This algorithm is similar to method Difference().
175    * Returns True if contents of this map is changed.
176    */
177   Standard_EXPORT Standard_Boolean Differ (const TColStd_PackedMapOfInteger&);
178
179   /**
180    * Overloaded operator version of Differ().
181    */
182   TColStd_PackedMapOfInteger& operator ^= (const TColStd_PackedMapOfInteger& MM)
183   { Differ(MM); return *this; }
184
185   /**
186    * Returns True if this map is equal to the given one, i.e. they contain the
187    * same sets of elements
188    */
189   Standard_EXPORT Standard_Boolean IsEqual (const TColStd_PackedMapOfInteger&) const;
190
191   /**
192    * Overloaded operator version of IsEqual().
193    */
194   Standard_Boolean operator == (const TColStd_PackedMapOfInteger& MM) const
195   { return IsEqual(MM); }
196
197   /**
198    * Returns True if this map is subset of the given one, i.e. all elements 
199    * contained in this map is contained also in the operand map.
200    * if this map is empty that this method returns true for any operand map.
201    */
202   Standard_EXPORT Standard_Boolean IsSubset (const TColStd_PackedMapOfInteger&) const;
203
204   /**
205    * Overloaded operator version of IsSubset().
206    */
207   Standard_Boolean operator <= (const TColStd_PackedMapOfInteger& MM) const
208   { return IsSubset(MM); }
209
210   /**
211    * Returns True if this map has common items with the given one.
212    */
213   Standard_EXPORT Standard_Boolean HasIntersection (const TColStd_PackedMapOfInteger&) const;
214
215   //!@}
216   
217  protected:
218   // ---------- PROTECTED METHODS ----------
219   inline Standard_Integer InternalExtent () const
220   { return TCollection_BasicMap::Extent(); }
221
222
223  private:
224   // ----------- PRIVATE (PROHIBITED) methods
225   /// Copy constructor - prohibited.
226   TColStd_PackedMapOfInteger (const TColStd_PackedMapOfInteger& theOther);
227
228
229   // ---------- PRIVATE FIELDS ----------
230
231   size_t                myExtent;
232
233   friend class TColStd_MapIteratorOfPackedMapOfInteger;
234 };
235
236 #endif