1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the class library */ 4 /* SoPlex --- the Sequential object-oriented simPlex. */ 5 /* */ 6 /* Copyright (c) 1996-2023 Zuse Institute Berlin (ZIB) */ 7 /* */ 8 /* Licensed under the Apache License, Version 2.0 (the "License"); */ 9 /* you may not use this file except in compliance with the License. */ 10 /* You may obtain a copy of the License at */ 11 /* */ 12 /* http://www.apache.org/licenses/LICENSE-2.0 */ 13 /* */ 14 /* Unless required by applicable law or agreed to in writing, software */ 15 /* distributed under the License is distributed on an "AS IS" BASIS, */ 16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ 17 /* See the License for the specific language governing permissions and */ 18 /* limitations under the License. */ 19 /* */ 20 /* You should have received a copy of the Apache-2.0 license */ 21 /* along with SoPlex; see the file LICENSE. If not email to soplex@zib.de. */ 22 /* */ 23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 24 25 /**@file didxset.h 26 * @brief Dymnamic index set. 27 */ 28 #ifndef _DIDXSET_H_ 29 #define _DIDXSET_H_ 30 31 #include <assert.h> 32 33 #include "soplex/idxset.h" 34 35 namespace soplex 36 { 37 38 /**@brief Dynamic index set. 39 @ingroup Elementary 40 41 Class DIdxSet provides dynamic IdxSet in the sense, that no 42 restrictions are posed on the use of methods add(). However, method 43 indexMem() has been moved to the private members. This is because 44 DIdxSet adds its own memory management to class IdxSet and the user must 45 not interfere with it. 46 47 Upon construction of an DIdxSet, memory is allocated automatically. The 48 memory consumption can be controlled with methods max() and setMax(). 49 Finally, the destructor will release all allocated memory. 50 */ 51 class DIdxSet : public IdxSet 52 { 53 public: 54 55 //----------------------------------- 56 /**@name Adding */ 57 ///@{ 58 /// adds \p n uninitialized indices. 59 void add(int n) 60 { 61 if(max() - size() < n) 62 setMax(size() + n); 63 64 IdxSet::add(n); 65 } 66 67 /// adds all indices from \p sv. 68 void add(const IdxSet& sv) 69 { 70 int n = sv.size(); 71 72 if(max() - size() < n) 73 setMax(size() + n); 74 75 IdxSet::add(sv); 76 } 77 78 /// adds \p n indices from \p i. 79 void add(int n, const int* i) 80 { 81 if(max() - size() < n) 82 setMax(size() + n); 83 84 IdxSet::add(n, i); 85 } 86 87 /// adds index \p i to the index set 88 void addIdx(int i) 89 { 90 if(max() <= size()) 91 setMax(size() + 1); 92 93 IdxSet::addIdx(i); 94 } 95 96 /// sets the maximum number of indices. 97 /** This methods resets the memory consumption of the DIdxSet to 98 * \p newmax. However, if \p newmax < size(), it is reset to size() 99 * only. 100 */ 101 void setMax(int newmax = 1); 102 ///@} 103 104 //----------------------------------- 105 /**@name Construction / destruction */ 106 ///@{ 107 /// default constructor. \p n gives the initial size of the index space. 108 explicit DIdxSet(int n = 8); 109 110 /// copy constructor from IdxSet. 111 explicit DIdxSet(const IdxSet& old); 112 113 /// copy constructor from DIdxSet. 114 DIdxSet(const DIdxSet& old); 115 116 /// assignment operator from IdxSet 117 DIdxSet& operator=(const IdxSet& sv) 118 { 119 if(this != &sv) 120 { 121 setMax(sv.size()); 122 IdxSet::operator=(sv); 123 } 124 125 return *this; 126 } 127 /// assignment operator from DIdxSet 128 DIdxSet& operator=(const DIdxSet& sv) 129 { 130 if(this != &sv) 131 { 132 setMax(sv.size()); 133 IdxSet::operator=(sv); 134 } 135 136 return *this; 137 } 138 /// destructor. 139 virtual ~DIdxSet(); 140 ///@} 141 }; 142 143 } // namespace soplex 144 #endif // _DIDXSET_H_ 145