00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef OST_MM_INDEX_HH
00021 #define OST_MM_INDEX_HH
00022
00023
00024
00025
00026
00027 #include <algorithm>
00028
00029 #include <cstring>
00030
00031 namespace ost { namespace mol{ namespace mm{
00032
00033 namespace impl {
00034 template <uint D>
00035 class IndexBase {
00036 public:
00037 enum { Dimension = D };
00038 IndexBase(const IndexBase& rhs) {
00039 memcpy(data_, rhs.data_, sizeof(uint[D]));
00040 }
00041 IndexBase() {
00042 memset(data_, 0, sizeof(uint[D]));
00043 }
00044
00045 IndexBase& operator=(const IndexBase& rhs) {
00046 memcpy(data_, rhs.data_, sizeof(uint[D]));
00047 return *this;
00048 }
00049 uint operator[](uint idx) const {
00050 assert(idx < D);
00051 return data_[idx];
00052 }
00053 uint& operator[](uint idx) {
00054 assert(idx < D);
00055 return data_[idx];
00056 }
00057
00058 inline bool operator < (const IndexBase<D>& rhs) const{
00059 return std::lexicographical_compare(data_, data_+D, rhs.data_, rhs.data_+D);
00060 }
00061
00062 inline bool operator==(const IndexBase<D>& rhs) const{
00063 return std::equal(data_,data_+D,rhs.data_);
00064 }
00065
00066 inline bool operator!=(const IndexBase<D>& rhs) const{
00067 return !(*this == rhs);
00068 }
00069
00070 private:
00071 uint data_[D];
00072 };
00073
00074 }
00075
00076 template <uint D>
00077 class Index;
00078
00079 template <>
00080 class Index<1> : public impl::IndexBase<1> {
00081 public:
00082 Index() : impl::IndexBase<1>() {}
00083 Index(uint a) {
00084 (*this)[0]=a;
00085 }
00086 template <typename DS>
00087 void Serialize(DS& ds){
00088 ds & (*this)[0];
00089 }
00090 };
00091 template <>
00092 class Index<2> : public impl::IndexBase<2> {
00093 public:
00094 Index() : impl::IndexBase<2>() {}
00095 Index(uint a, uint b) {
00096 (*this)[0]=a;
00097 (*this)[1]=b;
00098 }
00099 template <typename DS>
00100 void Serialize(DS& ds){
00101 ds & (*this)[0];
00102 ds & (*this)[1];
00103 }
00104 };
00105 template <>
00106 class Index<3> : public impl::IndexBase<3> {
00107 public:
00108 Index() : impl::IndexBase<3>() {}
00109 Index(uint a, uint b, uint c) {
00110 (*this)[0]=a;
00111 (*this)[1]=b;
00112 (*this)[2]=c;
00113 }
00114 template <typename DS>
00115 void Serialize(DS& ds){
00116 ds & (*this)[0];
00117 ds & (*this)[1];
00118 ds & (*this)[2];
00119 }
00120 };
00121 template <>
00122 class Index<4> : public impl::IndexBase<4> {
00123 public:
00124 Index() : impl::IndexBase<4>() {}
00125 Index(uint a, uint b, uint c, uint d) {
00126 (*this)[0]=a;
00127 (*this)[1]=b;
00128 (*this)[2]=c;
00129 (*this)[3]=d;
00130 }
00131 template <typename DS>
00132 void Serialize(DS& ds){
00133 ds & (*this)[0];
00134 ds & (*this)[1];
00135 ds & (*this)[2];
00136 ds & (*this)[3];
00137 }
00138 };
00139 template <>
00140 class Index<5> : public impl::IndexBase<5> {
00141 public:
00142 Index() : impl::IndexBase<5>() {}
00143 Index(uint a, uint b, uint c, uint d, uint e) {
00144 (*this)[0]=a;
00145 (*this)[1]=b;
00146 (*this)[2]=c;
00147 (*this)[3]=d;
00148 (*this)[4]=e;
00149 }
00150 template <typename DS>
00151 void Serialize(DS& ds){
00152 ds & (*this)[0];
00153 ds & (*this)[1];
00154 ds & (*this)[2];
00155 ds & (*this)[3];
00156 ds & (*this)[4];
00157 }
00158 };
00159 template <>
00160 class Index<6> : public impl::IndexBase<6> {
00161 public:
00162 Index() : impl::IndexBase<6>() {}
00163 Index(uint a, uint b, uint c, uint d, uint e, uint f) {
00164 (*this)[0]=a;
00165 (*this)[1]=b;
00166 (*this)[2]=c;
00167 (*this)[3]=d;
00168 (*this)[4]=e;
00169 (*this)[5]=f;
00170 }
00171 template <typename DS>
00172 void Serialize(DS& ds){
00173 ds & (*this)[0];
00174 ds & (*this)[1];
00175 ds & (*this)[2];
00176 ds & (*this)[3];
00177 ds & (*this)[4];
00178 ds & (*this)[5];
00179 }
00180 };
00181 template <>
00182 class Index<7> : public impl::IndexBase<7> {
00183 public:
00184 Index() : impl::IndexBase<7>() {}
00185 Index(uint a, uint b, uint c, uint d, uint e, uint f, uint g) {
00186 (*this)[0]=a;
00187 (*this)[1]=b;
00188 (*this)[2]=c;
00189 (*this)[3]=d;
00190 (*this)[4]=e;
00191 (*this)[5]=f;
00192 (*this)[6]=g;
00193 }
00194 template <typename DS>
00195 void Serialize(DS& ds){
00196 ds & (*this)[0];
00197 ds & (*this)[1];
00198 ds & (*this)[2];
00199 ds & (*this)[3];
00200 ds & (*this)[4];
00201 ds & (*this)[5];
00202 ds & (*this)[6];
00203 }
00204 };
00205 template<uint D>
00206 class IndexIterator {
00207 public:
00208 typedef Index<D> IndexType;
00209 IndexIterator(const IndexType& s, const IndexType& e)
00210 : start_(s), end_(e), current_(s) {
00211
00212 }
00213
00214 IndexIterator<D>& operator++() {
00215 uint current_it=0;
00216 while (++current_[current_it] > end_[current_it]) {
00217 current_it++;
00218 if (current_it < D) {
00219 current_[current_it-1] = start_[current_it-1];
00220 } else {
00221 break;
00222 }
00223 }
00224 return *this;
00225 }
00226 const IndexType& operator *() const {
00227 return current_;
00228 }
00229 bool AtEnd() {
00230 return current_[D-1] > end_[D-1];
00231 }
00232 private:
00233 IndexType start_;
00234 IndexType end_;
00235 IndexType current_;
00236
00237 };
00238
00239 }}}
00240
00241 #endif