1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// This is mul/mbl/mbl_data_array_wrapper.txx
#ifndef mbl_data_array_wrapper_txx_
#define mbl_data_array_wrapper_txx_
//:
// \file
#include "mbl_data_array_wrapper.h"
#include <vcl_iostream.h>
#include <vcl_cstdlib.h>
#include <vcl_cassert.h>
//: Default constructor
template<class T>
mbl_data_array_wrapper<T>::mbl_data_array_wrapper()
: data_(0),n_(0),index_(0)
{
}
//: Constructor
template<class T>
mbl_data_array_wrapper<T>::mbl_data_array_wrapper(const T* data, unsigned long n)
{
set(data,n);
}
//: Constructor
// Sets up object to wrap a vcl_vector.
// The data must be kept in scope, this does not take a copy.
template<class T>
mbl_data_array_wrapper<T>::mbl_data_array_wrapper(const vcl_vector<T > &data)
{
// There is nothing in the STL standard that says that vector<> has
// to store its data in a contiguous memory block. However, most
// implementations do store data this way.
// Check this assumption holds.
assert(data.size() == 0 || &data[data.size() - 1] + 1 == &data[0] + data.size());
set(data.empty()?0:&data[0], data.size());
}
//: Copy Constructor
// The copy will point to the same data as the original.
// The data must be kept in scope, this does not take a copy.
template <class T>
mbl_data_array_wrapper<T>::mbl_data_array_wrapper(const mbl_data_array_wrapper<T > &orig)
: mbl_data_wrapper<T>()
{
set(orig.data_, orig.size());
}
//: Initialise to return elements from data[i]
template<class T>
void mbl_data_array_wrapper<T>::set(const T* data, unsigned long n)
{
assert (n != ((unsigned long)-1)); // a common mistake
data_ = data;
n_ = n;
index_ = 0;
}
//: Default destructor
template<class T>
mbl_data_array_wrapper<T>::~mbl_data_array_wrapper()
{
}
//: Number of objects available
template<class T>
unsigned long mbl_data_array_wrapper<T>::size() const
{
return n_;
}
//: Reset so that current() returns first object
template<class T>
void mbl_data_array_wrapper<T>::reset()
{
index_=0;
}
//: Return current object
template<class T>
const T& mbl_data_array_wrapper<T>::current()
{
return data_[index_];
}
//: Move to next object, returning true if is valid
template<class T>
bool mbl_data_array_wrapper<T>::next()
{
index_++;
return index_<n_;
}
//: Return current index
template<class T>
unsigned long mbl_data_array_wrapper<T>::index() const
{
return index_;
}
//: Create copy on heap and return base pointer
template<class T>
mbl_data_wrapper< T >* mbl_data_array_wrapper<T>::clone() const
{
return new mbl_data_array_wrapper<T>(*this);
}
//: Move to element n
// First example has index 0
template<class T>
void mbl_data_array_wrapper<T>::set_index(unsigned long n)
{
assert(n != ((unsigned)-1));
if (n>=n_)
{
vcl_cerr<<"mbl_data_array_wrapper<T>::set_index(n) :\n"
<<" n = "<<n<<" not in range 0<=n<"<<size()<<vcl_endl;
vcl_abort();
}
index_=n;
}
template <class T>
bool mbl_data_array_wrapper<T>::is_class(vcl_string const& s) const
{
return s==is_a(); // no ref to parent's is_class() since that is pure virtual
}
#define MBL_DATA_ARRAY_WRAPPER_INSTANTIATE(T) \
VCL_DEFINE_SPECIALIZATION vcl_string mbl_data_array_wrapper<T >::is_a() const \
{ return vcl_string("mbl_data_array_wrapper<" #T ">"); } \
template class mbl_data_array_wrapper< T >
#endif // mbl_data_array_wrapper_txx_
|
