BCP_vector_short.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 template<> inline void BCP_vec<short>::destroy(iterator pos)
14 {
15 }
16 //------------------------------------------------------------------------------
17 template<> inline void BCP_vec<short>::destroy_range(iterator first, iterator last)
18 {
19 }
20 //------------------------------------------------------------------------------
21 template<> inline void BCP_vec<short>::construct(iterator pos)
22 {
23  *pos = 0;
24 }
25 //------------------------------------------------------------------------------
26 template<> inline void BCP_vec<short>::construct(iterator pos, const_reference x)
27 {
28  *pos = x;
29 }
30 
31 //##############################################################################
32 
33 // template<> inline void BCP_vec<short>::allocate(size_t len)
34 //------------------------------------------------------------------------------
35 template<> inline void BCP_vec<short>::deallocate() {
36  if (start) {
37  ::operator delete(start);
38  }
39 }
40 //------------------------------------------------------------------------------
41 template<> void BCP_vec<short>::insert_aux(iterator position, const_reference x);
42 
43 //##############################################################################
44 
45 // template<> void BCP_vec<short>::BCP_vec();
46 //------------------------------------------------------------------------------
47 // template<> void BCP_vec<short>::BCP_vec(const BCP_vec<short>& x);
48 //------------------------------------------------------------------------------
49 template<> BCP_vec<short>::BCP_vec(const size_t n, const_reference value);
50 //------------------------------------------------------------------------------
51 template<> BCP_vec<short>::BCP_vec(const_iterator first, const_iterator last);
52 //------------------------------------------------------------------------------
53 template<> BCP_vec<short>::BCP_vec(const short* x, const size_t num);
54 
55 //##############################################################################
56 
57 template<> void BCP_vec<short>::reserve(const size_t n);
58 //------------------------------------------------------------------------------
59 // template<> inline void BCP_vec<short>::swap(BCP_vec<short>& x);
60 //------------------------------------------------------------------------------
61 template<> BCP_vec<short>& BCP_vec<short>::operator=(const BCP_vec<short>& x);
62 
63 //##############################################################################
64 // these two members serve to copy out entries from a buffer.
65 
66 template<> void BCP_vec<short>::assign(const void* x, const size_t num);
67 //------------------------------------------------------------------------------
68 template<> void BCP_vec<short>::insert(short* position,
69  const void* first, const size_t n);
70 //------------------------------------------------------------------------------
71 template<> void BCP_vec<short>::insert(iterator position,
72  const_iterator first,
73  const_iterator last);
74 //------------------------------------------------------------------------------
75 template<> void BCP_vec<short>::insert(iterator position, const size_t n,
76  const_reference x);
77 //------------------------------------------------------------------------------
78 template<> inline BCP_vec<short>::iterator
79 BCP_vec<short>::insert(iterator position, const_reference x)
80 {
81  const size_t n = position - start;
82  if (finish != end_of_storage && position == finish) {
83  *finish++ = x;
84  } else
85  insert_aux(position, x);
86  return start + n;
87 }
88 
89 //##############################################################################
90 
91 template<> inline void BCP_vec<short>::push_back(const_reference x)
92 {
93  if (finish != end_of_storage)
94  *finish++ = x;
95  else
96  insert_aux(finish, x);
97 }
98 //------------------------------------------------------------------------------
99 template<> inline void BCP_vec<short>::unchecked_push_back(const_reference x)
100 {
101  *finish++ = x;
102 }
103 //------------------------------------------------------------------------------
104 template<> inline void BCP_vec<short>::pop_back()
105 {
106  --finish;
107 }
108 //------------------------------------------------------------------------------
109 // template<> inline void BCP_vec<short>::clear();
110 //------------------------------------------------------------------------------
111 template<> inline void
112 BCP_vec<short>::unchecked_update(const BCP_vec<int>& positions,
113  const BCP_vec<short>& values)
114 {
115  if (positions.size() == 0)
116  return;
117  const_iterator val = values.begin();
118  BCP_vec<int>::const_iterator pos = positions.begin();
119  const BCP_vec<int>::const_iterator lastpos = positions.end();
120  while (pos != lastpos)
121  operator[](*pos++) = *val++;
122 }
123 //------------------------------------------------------------------------------
124 template<> inline void BCP_vec<short>::update(const BCP_vec<int>& positions,
125  const BCP_vec<short>& values)
126 {
127  if (positions.size() != values.size())
128  throw BCP_fatal_error("BCP_vec::update() called with unequal sizes.\n");
129  BCP_vec_sanity_check(positions.begin(), positions.end(), size());
130  unchecked_update(positions, values);
131 }
132 
133 //##############################################################################
134 
135 template<> inline void BCP_vec<short>::keep(iterator pos)
136 {
137  *start = *pos;
138  finish = start + 1;
139 }
140 //------------------------------------------------------------------------------
141 template<> inline void BCP_vec<short>::keep(iterator first, iterator last)
142 {
143  const size_t len = last - first;
144  std::memmove(start, first, len * sizeof(short));
145  finish = start + len;
146 }
147 //------------------------------------------------------------------------------
148 // template<> inline void
149 // BCP_vec<short>::unchecked_keep_by_index(BCP_vec<int>::const_iterator firstpos,
150 // BCP_vec<int>::const_iterator lastpos);
151 //------------------------------------------------------------------------------
152 // template<> inline void
153 // BCP_vec<short>::keep_by_index(BCP_vec<int>::const_iterator firstpos,
154 // BCP_vec<int>::const_iterator lastpos);
155 //------------------------------------------------------------------------------
156 // template<> inline void
157 // BCP_vec<short>::keep_by_index(const BCP_vec<int>& positions);
158 //------------------------------------------------------------------------------
159 // template<> inline void
160 // BCP_vec<short>::unchecked_keep_by_index(const BCP_vec<int>& positions);
161 
162 //##############################################################################
163 
164 template<> inline void BCP_vec<short>::erase(iterator position)
165 {
166  if (position + 1 != finish)
167  std::memmove(position, position + 1, ((finish-position) - 1) * sizeof(short));
168  --finish;
169 }
170 //------------------------------------------------------------------------------
171 template<> inline void BCP_vec<short>::erase(iterator first, iterator last)
172 {
173  if (first != last && last != finish)
174  std::memmove(first, last, (finish - last) * sizeof(short));
175  finish -= (last - first);
176 }
177 //------------------------------------------------------------------------------
178 // template <class T> inline void
179 // BCP_vec<T>::erase_by_index(const BCP_vec<int>& positions);
180 //------------------------------------------------------------------------------
181 // template <class T> inline void
182 // BCP_vec<T>::unchecked_erase_by_index(const BCP_vec<int>& positions);
183 //------------------------------------------------------------------------------
184 // template <class T> inline void
185 // BCP_vec<T>::erase_by_index(BCP_vec<int>::const_iterator firstpos,
186 // BCP_vec<int>::const_iterator lastpos);
187 //------------------------------------------------------------------------------
188 // template <class T> void
189 // BCP_vec<T>::unchecked_erase_by_index(BCP_vec<int>::const_iterator firstpos,
190 // BCP_vec<int>::const_iterator lastpos);
191 
192 //#############################################################################
193 
values
double * values
Definition: BonFilterSolver.cpp:113
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
Couenne::pos
pos
position where the operator should be printed when printing the expression
Definition: CouenneTypes.hpp:30
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.
Definition: BCP_vector_sanity.cpp:8
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
n
void fint * n
Definition: BonFilterSolver.cpp:96
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
x
void fint fint fint real fint real * x
Definition: BonBqpdSolver.cpp:27
BCP_vec::destroy
void destroy(iterator pos)
Definition: BCP_vector_general.hpp:6
Generated by   doxygen 1.8.5