coin-Bcp
BCP_vector_bool.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 
4 #include <cstring>
5 
6 //##############################################################################
7 
8 /* The methods that are commented out are sort of generic methods that do not
9  need specialization. Their implementation is in BCP_vector_general.hpp */
10 
11 //##############################################################################
12 
13 // to get memmove
14 #include <cstring>
15 
16 template<> inline void BCP_vec<bool>::destroy(iterator pos)
17 {
18 }
19 //------------------------------------------------------------------------------
20 template<> inline void BCP_vec<bool>::destroy_range(iterator first, iterator last)
21 {
22 }
23 //------------------------------------------------------------------------------
24 template<> inline void BCP_vec<bool>::construct(iterator pos)
25 {
26  *pos = 0;
27 }
28 //------------------------------------------------------------------------------
29 template<> inline void BCP_vec<bool>::construct(iterator pos, const_reference x)
30 {
31  *pos = x;
32 }
33 
34 //##############################################################################
35 
36 // template<> inline void BCP_vec<bool>::allocate(size_t len)
37 //------------------------------------------------------------------------------
38 template<> inline void BCP_vec<bool>::deallocate() {
39  if (start) {
40  ::operator delete(start);
41  }
42 }
43 //------------------------------------------------------------------------------
44 template<> void BCP_vec<bool>::insert_aux(iterator position, const_reference x);
45 
46 //##############################################################################
47 
48 // template<> void BCP_vec<bool>::BCP_vec();
49 //------------------------------------------------------------------------------
50 // template<> void BCP_vec<bool>::BCP_vec(const BCP_vec<bool>& x);
51 //------------------------------------------------------------------------------
52 template<> BCP_vec<bool>::BCP_vec(const size_t n, const_reference value);
53 //------------------------------------------------------------------------------
54 template<> BCP_vec<bool>::BCP_vec(const_iterator first, const_iterator last);
55 //------------------------------------------------------------------------------
56 template<> BCP_vec<bool>::BCP_vec(const bool* x, const size_t num);
57 
58 //##############################################################################
59 
60 template<> void BCP_vec<bool>::reserve(const size_t n);
61 //------------------------------------------------------------------------------
62 // template<> inline void BCP_vec<bool>::swap(BCP_vec<bool>& x);
63 //------------------------------------------------------------------------------
64 template<> BCP_vec<bool>& BCP_vec<bool>::operator=(const BCP_vec<bool>& x);
65 
66 //##############################################################################
67 // these two members serve to copy out entries from a buffer.
68 
69 template<> void BCP_vec<bool>::assign(const void* x, const size_t num);
70 //------------------------------------------------------------------------------
71 template<> void BCP_vec<bool>::insert(bool* position,
72  const void* first, const size_t n);
73 //------------------------------------------------------------------------------
74 template<> void BCP_vec<bool>::insert(iterator position,
75  const_iterator first,
76  const_iterator last);
77 //------------------------------------------------------------------------------
78 template<> void BCP_vec<bool>::insert(iterator position, const size_t n,
79  const_reference x);
80 //------------------------------------------------------------------------------
81 template<> inline BCP_vec<bool>::iterator
82 BCP_vec<bool>::insert(iterator position, const_reference x)
83 {
84  const size_t n = position - start;
85  if (finish != end_of_storage && position == finish) {
86  *finish++ = x;
87  } else
88  insert_aux(position, x);
89  return start + n;
90 }
91 
92 //##############################################################################
93 
94 template<> inline void BCP_vec<bool>::push_back(const_reference x)
95 {
96  if (finish != end_of_storage)
97  *finish++ = x;
98  else
99  insert_aux(finish, x);
100 }
101 //------------------------------------------------------------------------------
102 template<> inline void BCP_vec<bool>::unchecked_push_back(const_reference x)
103 {
104  *finish++ = x;
105 }
106 //------------------------------------------------------------------------------
107 template<> inline void BCP_vec<bool>::pop_back()
108 {
109  --finish;
110 }
111 //------------------------------------------------------------------------------
112 // template<> inline void BCP_vec<bool>::clear();
113 //------------------------------------------------------------------------------
114 template<> inline void
115 BCP_vec<bool>::unchecked_update(const BCP_vec<int>& positions,
116  const BCP_vec<bool>& values)
117 {
118  if (positions.size() == 0)
119  return;
120  const_iterator val = values.begin();
121  BCP_vec<int>::const_iterator pos = positions.begin();
122  const BCP_vec<int>::const_iterator lastpos = positions.end();
123  while (pos != lastpos)
124  operator[](*pos++) = *val++;
125 }
126 
127 //------------------------------------------------------------------------------
128 template<> inline void BCP_vec<bool>::update(const BCP_vec<int>& positions,
129  const BCP_vec<bool>& values)
130 {
131  if (positions.size() != values.size())
132  throw BCP_fatal_error("BCP_vec::update() called with unequal sizes.\n");
133  BCP_vec_sanity_check(positions.begin(), positions.end(), size());
134  unchecked_update(positions, values);
135 }
136 
137 //##############################################################################
138 
139 template<> inline void BCP_vec<bool>::keep(iterator pos)
140 {
141  *start = *pos;
142  finish = start + 1;
143 }
144 //------------------------------------------------------------------------------
145 template<> inline void BCP_vec<bool>::keep(iterator first, iterator last)
146 {
147  const size_t len = last - first;
148  std::memmove(start, first, len * sizeof(bool));
149  finish = start + len;
150 }
151 //------------------------------------------------------------------------------
152 // template<> inline void
153 // BCP_vec<bool>::unchecked_keep_by_index(BCP_vec<int>::const_iterator firstpos,
154 // BCP_vec<int>::const_iterator lastpos);
155 //------------------------------------------------------------------------------
156 // template<> inline void
157 // BCP_vec<bool>::keep_by_index(BCP_vec<int>::const_iterator firstpos,
158 // BCP_vec<int>::const_iterator lastpos);
159 //------------------------------------------------------------------------------
160 // template<> inline void
161 // BCP_vec<bool>::keep_by_index(const BCP_vec<int>& positions);
162 //------------------------------------------------------------------------------
163 // template<> inline void
164 // BCP_vec<bool>::unchecked_keep_by_index(const BCP_vec<int>& positions);
165 
166 //##############################################################################
167 
168 template<> inline void BCP_vec<bool>::erase(iterator position)
169 {
170  if (position + 1 != finish)
171  std::memmove(position, position + 1, ((finish-position) - 1) * sizeof(bool));
172  --finish;
173 }
174 //------------------------------------------------------------------------------
175 template<> inline void BCP_vec<bool>::erase(iterator first, iterator last)
176 {
177  if (first != last && last != finish)
178  std::memmove(first, last, (finish - last) * sizeof(bool));
179  finish -= (last - first);
180 }
181 //------------------------------------------------------------------------------
182 // template <class T> inline void
183 // BCP_vec<T>::erase_by_index(const BCP_vec<int>& positions);
184 //------------------------------------------------------------------------------
185 // template <class T> inline void
186 // BCP_vec<T>::unchecked_erase_by_index(const BCP_vec<int>& positions);
187 //------------------------------------------------------------------------------
188 // template <class T> inline void
189 // BCP_vec<T>::erase_by_index(BCP_vec<int>::const_iterator firstpos,
190 // BCP_vec<int>::const_iterator lastpos);
191 //------------------------------------------------------------------------------
192 // template <class T> void
193 // BCP_vec<T>::unchecked_erase_by_index(BCP_vec<int>::const_iterator firstpos,
194 // BCP_vec<int>::const_iterator lastpos);
195 
196 //#############################################################################
197 
BCP_vec::deallocate
void deallocate()
Destroy the entries in the vector and free the memory allocated for the vector.
Definition: BCP_vector_general.hpp:35
BCP_vec::insert_aux
void insert_aux(iterator position, const_reference x)
insert x into the given position in the vector.
Definition: BCP_vector_general.hpp:43
BCP_vec::const_reference
const T & const_reference
Definition: BCP_vector.hpp:39
BCP_vec::begin
iterator begin()
Return an iterator to the beginning of the object.
Definition: BCP_vector.hpp:99
BCP_vec::unchecked_update
void unchecked_update(const BCP_vec< int > &positions, const BCP_vec< T > &values)
Same as the previous method but without sanity checks.
Definition: BCP_vector_general.hpp:324
BCP_vec::reserve
void reserve(const size_t n)
Reallocate the object to make space for n entries.
Definition: BCP_vector_general.hpp:112
BCP_vec::push_back
void push_back(const_reference x)
Append x to the end of the vector.
Definition: BCP_vector_general.hpp:300
BCP_vec::operator=
BCP_vec< T > & operator=(const BCP_vec< T > &x)
Copy the contents of x into the object and return a reference the the object itself.
Definition: BCP_vector_general.hpp:131
BCP_vec::construct
void construct(iterator pos)
Definition: BCP_vector_general.hpp:18
BCP_vec::iterator
T * iterator
Definition: BCP_vector.hpp:33
BCP_vec::erase
void erase(iterator pos)
Erase the entry pointed to by pos.
Definition: BCP_vector_general.hpp:399
BCP_vec::pop_back
void pop_back()
Delete the last entry.
Definition: BCP_vector_general.hpp:313
BCP_vec::update
void update(const BCP_vec< int > &positions, const BCP_vec< T > &values)
Update those entries listed in positions to the given values.
Definition: BCP_vector_general.hpp:336
BCP_vec::destroy_range
void destroy_range(iterator first, iterator last)
Definition: BCP_vector_general.hpp:11
BCP_vec::BCP_vec
BCP_vec()
The default constructor initializes the data members as 0 pointers.
Definition: BCP_vector_general.hpp:65
BCP_vec::insert
void insert(iterator position, const void *first, const size_t num)
Insert num entries starting from memory location first into the vector from position pos...
Definition: BCP_vector_general.hpp:176
BCP_vec_sanity_check
void BCP_vec_sanity_check(BCP_vec< int >::const_iterator firstpos, BCP_vec< int >::const_iterator lastpos, const int maxsize)
A helper function to test whether a set positions is sane for a vector.
BCP_fatal_error
Currently there isn&#39;t any error handling in BCP.
Definition: BCP_error.hpp:20
BCP_vec::size
size_t size() const
Return the current number of entries.
Definition: BCP_vector.hpp:116
BCP_vec::end
iterator end()
Return an iterator to the end of the object.
Definition: BCP_vector.hpp:104
BCP_vec
The class BCP_vec serves the same purpose as the vector class in the standard template library...
Definition: BCP_vector.hpp:24
BCP_vec::unchecked_push_back
void unchecked_push_back(const_reference x)
Append x to the end of the vector.
Definition: BCP_vector_general.hpp:308
BCP_vec::keep
void keep(iterator pos)
Keep only the entry pointed to by pos.
Definition: BCP_vector_general.hpp:347
BCP_vec::assign
void assign(const void *x, const size_t num)
Copy num entries of type T starting at the memory location x into the object.
Definition: BCP_vector_general.hpp:157
BCP_vec::const_iterator
const T * const_iterator
Definition: BCP_vector.hpp:35
BCP_vec::destroy
void destroy(iterator pos)
Definition: BCP_vector_general.hpp:6
Generated by   doxygen 1.8.5