From 210f77d2c32f14d2e99577fd3c9842bb19d47e50 Mon Sep 17 00:00:00 2001 From: Tuowen Zhao Date: Mon, 19 Sep 2016 21:14:58 +0000 Subject: Moved most modules into lib --- lib/omega/include/basic/DynamicArray.h | 318 +++++++++++++++++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100644 lib/omega/include/basic/DynamicArray.h (limited to 'lib/omega/include/basic/DynamicArray.h') diff --git a/lib/omega/include/basic/DynamicArray.h b/lib/omega/include/basic/DynamicArray.h new file mode 100644 index 0000000..08f8b91 --- /dev/null +++ b/lib/omega/include/basic/DynamicArray.h @@ -0,0 +1,318 @@ +#ifndef Already_Included_DynamicArray +#define Already_Included_DynamicArray + +#include + +namespace omega { + +template class DynamicArray2; +template class DynamicArray3; +template class DynamicArray4; + +template class DynamicArray + { + public: + DynamicArray(DynamicArray &D); + ~DynamicArray(); + + protected: + DynamicArray(); + bool partial; + int *bounds; + T *elements; + + void do_constr(); + void do_destruct(); + }; + + +template class DynamicArray1 : public DynamicArray + { + public: + DynamicArray1(const char *s0 = 0); + DynamicArray1(int d0); + void resize(int d0); + T& operator[](int d); + + friend class DynamicArray2; + + private: + void do_construct(int d0); + }; + + +template class DynamicArray2 : public DynamicArray + { + public: + DynamicArray2(const char *s0 = 0, const char *s1 = 0); + DynamicArray2(int d0, int d1); + void resize(int d0, int d1); + DynamicArray1 operator[](int d); + + friend class DynamicArray3; + + private: + void do_construct(int d0, int d1); + }; + + +template class DynamicArray3 : public DynamicArray + { + public: + DynamicArray3(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0); + DynamicArray3(int d0, int d1, int d2); + void resize(int d0, int d1, int d2); + DynamicArray2 operator[](int d); + + friend class DynamicArray4; + + private: + void do_construct(int d0, int d1, int d2); + }; + +template class DynamicArray4 : public DynamicArray + { + public: + DynamicArray4(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0, const char *s3 = 0); + DynamicArray4(int d0, int d1, int d2, int d3); + void resize(int d0, int d1, int d2, int d3); + DynamicArray3 operator[](int d); + + private: + void do_construct(int d0, int d1, int d2, int d3); + }; + +} // namespace + +#define instantiate_DynamicArray1(T) template class DynamicArray1; \ + template class DynamicArray; + +#define instantiate_DynamicArray2(T) template class DynamicArray2; \ + template class DynamicArray; \ + instantiate_DynamicArray1(T); + +#define instantiate_DynamicArray3(T) template class DynamicArray3; \ + template class DynamicArray; \ + instantiate_DynamicArray2(T); + +#define instantiate_DynamicArray4(T) template class DynamicArray4; \ + template class DynamicArray; \ + instantiate_DynamicArray3(T); + +namespace omega { + +template void DynamicArray::do_constr() + { +// #if ! defined SHUT_UP_ABOUT_STATEMENT_WITH_NO_EFFECT_IN_DYNAMIC_ARRAY_CREATION +// assert(d > 0); +// #endif + bounds = 0; + elements = 0; + partial = false; + } + + +template void DynamicArray1::do_construct(int d0) + { + this->bounds = new int[1]; + this->bounds[0] = d0; + this->elements = new T [d0]; + this->partial = false; + } + +template void DynamicArray2::do_construct(int d0, int d1) + { + this->bounds = new int[2]; + this->bounds[0] = d0; + this->bounds[1] = d1; + this->elements = new T [d0 * d1]; + this->partial = false; + } + +template void DynamicArray3::do_construct(int d0,int d1,int d2) + { + this->bounds = new int[3]; + this->bounds[0] = d0; + this->bounds[1] = d1; + this->bounds[2] = d2; + this->elements = new T [d0 * d1 * d2]; + this->partial = false; + } + +template void DynamicArray4::do_construct(int d0,int d1,int d2,int d3) + { + this->bounds = new int[4]; + this->bounds[0] = d0; + this->bounds[1] = d1; + this->bounds[2] = d2; + this->bounds[3] = d3; + this->elements = new T [d0 * d1 * d2 * d3]; + this->partial = false; + } + +template DynamicArray::DynamicArray() + { + do_constr(); + } + +template DynamicArray1::DynamicArray1(const char *) + { + this->do_constr(); + } + +template DynamicArray2::DynamicArray2(const char *,const char *) + { + this->do_constr(); + } + +template DynamicArray3::DynamicArray3(const char *,const char *,const char *) + { + this->do_constr(); + } + +template DynamicArray4::DynamicArray4(const char *,const char *,const char *,const char *) + { + this->do_constr(); + } + +template DynamicArray1::DynamicArray1(int d0) + { + do_construct(d0); + } + +template DynamicArray2::DynamicArray2(int d0, int d1) + { + do_construct(d0, d1); + } + +template DynamicArray3::DynamicArray3(int d0,int d1,int d2) + { + do_construct(d0, d1, d2); + } + +template DynamicArray4::DynamicArray4(int d0,int d1,int d2,int d3) + { + do_construct(d0, d1, d2, d3); + } + + +template void DynamicArray::do_destruct() + { + if (! partial) + { + delete [] bounds; + delete [] elements; + } + } + + +template DynamicArray::~DynamicArray() + { + do_destruct(); + } + + +template void DynamicArray1::resize(int d0) + { + assert(!this->partial); + this->do_destruct(); + if (d0 == 0) + this->do_constr(); + else + do_construct(d0); + } + +template void DynamicArray2::resize(int d0, int d1) + { + assert(!this->partial); + this->do_destruct(); + if (d0 == 0 && d1 == 0) + this->do_constr(); + else + do_construct(d0, d1); + } + +template void DynamicArray3::resize(int d0, int d1, int d2) + { + assert(!this->partial); + this->do_destruct(); + if (d0 == 0 && d1 == 0 && d2 == 0) + this->do_constr(); + else + do_construct(d0, d1, d2); + } + +template void DynamicArray4::resize(int d0, int d1, int d2, int d3) + { + assert(!this->partial); + this->do_destruct(); + if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0) + this->do_constr(); + else + do_construct(d0, d1, d2, d3); + } + + +template T& DynamicArray1::operator[](int d0) + { +#if !defined (NDEBUG) + assert(this->elements != 0 && "Trying to dereference undefined array"); + assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); +#endif + + return this->elements[d0]; + } + +template DynamicArray1 DynamicArray2::operator[](int d0) + { +#if !defined (NDEBUG) + assert(this->elements != 0 && "Trying to dereference undefined array"); + assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); +#endif + + DynamicArray1 result; + result.bounds = this->bounds+1; + result.elements = this->elements + this->bounds[1] * d0; + result.partial = true; + return result; + } + +template DynamicArray2 DynamicArray3::operator[](int d0) + { +#if !defined (NDEBUG) + assert(this->elements != 0 && "Trying to dereference undefined array"); + assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); +#endif + DynamicArray2 result; + result.bounds = this->bounds+1; + result.elements = this->elements + this->bounds[1] * this->bounds[2] * d0; + result.partial = true; + return result; + } + +template DynamicArray3 DynamicArray4::operator[](int d0) + { +#if !defined (NDEBUG) + assert(this->elements != 0 && "Trying to dereference undefined array"); + assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); +#endif + + DynamicArray3 result; + result.bounds = this->bounds+1; + result.elements = this->elements + this->bounds[1] * this->bounds[2] * this->bounds[3] * d0; + result.partial = true; + return result; + } + + +template + DynamicArray::DynamicArray(DynamicArray &D) + { + assert(D.elements != 0 && "Trying to copy an undefined array"); + partial = true; + bounds = D.bounds; + elements = D.elements; + } + +} // namespace +#endif -- cgit v1.2.3-70-g09d2