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
|
/*
* File: fixedarray.h
* Summary: Fixed size 2D vector class that asserts if you do something bad.
* Written by: Jesse Jones
*/
#ifndef FIXARY_H
#define FIXARY_H
#include "fixedvector.h"
// ==========================================================================
// class FixedArray
// ==========================================================================
template <class TYPE, int WIDTH, int HEIGHT> class FixedArray {
//-----------------------------------
// Types
//
public:
typedef TYPE value_type;
typedef TYPE& reference;
typedef const TYPE& const_reference;
typedef TYPE* pointer;
typedef const TYPE* const_pointer;
typedef unsigned long size_type;
typedef long difference_type;
// operator[] should return one of these to avoid breaking
// client code (if inlining is on there won't be a speed hit)
typedef FixedVector<TYPE, HEIGHT> Column;
//-----------------------------------
// Initialization/Destruction
//
public:
~FixedArray() {}
FixedArray() {}
FixedArray(TYPE def)
{
init(def);
}
//-----------------------------------
// API
//
public:
// ----- Size -----
bool empty() const { return WIDTH == 0 || HEIGHT == 0; }
int size() const { return WIDTH*HEIGHT; }
int width() const { return WIDTH; }
int height() const { return HEIGHT; }
// ----- Access -----
Column& operator[](unsigned long index) { return mData[index]; }
const Column& operator[](unsigned long index) const {
return mData[index];
}
template<class Indexer> TYPE& operator () (const Indexer &i) {
return mData[i.x][i.y];
}
template<class Indexer> const TYPE& operator () (const Indexer &i) const {
return mData[i.x][i.y];
}
void init(const TYPE& def) {
for ( int i = 0; i < WIDTH; ++i )
mData[i].init(def);
}
protected:
FixedVector<Column, WIDTH> mData;
};
// A fixed array centered around the origin.
template <class TYPE, int RADIUS> class SquareArray {
//-----------------------------------
// Types
//
public:
typedef TYPE value_type;
typedef TYPE& reference;
typedef const TYPE& const_reference;
typedef TYPE* pointer;
typedef const TYPE* const_pointer;
typedef unsigned long size_type;
typedef long difference_type;
//-----------------------------------
// Initialization/Destruction
//
public:
~SquareArray() {}
SquareArray() {}
SquareArray(TYPE def)
{
init(def);
}
//-----------------------------------
// API
//
public:
// ----- Size -----
bool empty() const { return data.empty(); }
int size() const { return data.size(); }
int width() const { return data.width(); }
int height() const { return data.height(); }
// ----- Access -----
template<class Indexer> TYPE& operator () (const Indexer &i) {
return data[i.x+RADIUS][i.y+RADIUS];
}
template<class Indexer> const TYPE& operator () (const Indexer &i) const {
return data[i.x+RADIUS][i.y+RADIUS];
}
void init(const TYPE& def) {
data.init(def);
}
protected:
FixedArray<TYPE, 2*RADIUS+1, 2*RADIUS+1> data;
};
#endif // FIXARY_H
|
