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
|
/*
* File: fixary.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 "fixvec.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;
};
template <typename Z>
class Matrix {
public:
Matrix(int width, int height, const Z &initial);
Matrix(int width, int height);
~Matrix();
void init(const Z &initial);
Z &operator () (int x, int y)
{
return data[x + y * width];
}
const Z &operator () (int x, int y) const
{
return data[x + y * width];
}
private:
Z *data;
int width, height, size;
};
template <typename Z>
Matrix<Z>::Matrix(int _width, int _height, const Z &initial)
: data(NULL), width(_width), height(_height), size(_width * _height)
{
data = new Z [ size ];
init(initial);
}
template <typename Z>
Matrix<Z>::Matrix(int _width, int _height)
: data(NULL), width(_width), height(_height), size(_width * _height)
{
data = new Z [ size ];
}
template <typename Z>
Matrix<Z>::~Matrix()
{
delete [] data;
}
template <typename Z>
void Matrix<Z>::init(const Z &initial)
{
for (int i = 0; i < size; ++i)
data[i] = initial;
}
#endif // FIXARY_H
|
