Files
amscppnarray25/include/amscppnarray/amscppnarray_impl.hpp
T
2025-06-22 16:48:23 -04:00

524 lines
11 KiB
C++

#ifndef __AMSCPPNARRAY_IMPL_HPP__
#define __AMSCPPNARRAY_IMPL_HPP__
namespace ams
{
namespace narray
{
template<typename T> narray<T>::narray()
{
//printf("debug: constructor called for %p.\n",this);
length = 0;
data = NULL;
return;
}
template<typename T> int narray<T>::resize(const narray_size_t newlength)
{
int ret = narray_failure;
narray_size_t I;
T *newdata = NULL;
narray_size_t ml;
if(newlength<=0)
{
if(data!=NULL) {delete[] data; data=NULL;}
length = 0;
ret = narray_success;
return ret;
}
newdata = new(std::nothrow) T[newlength];
if(newdata==NULL)
{
ret = narray_failure;
return ret;
}
//threaded initialization for speed
ml = (length<newlength) ? length : newlength;
buffer_copycast<T,T>(newdata,data,ml);
buffer_set<T>(newdata,T(),length,newlength);
// for(I=0;I<length&I<newlength;I++)
// {
// newdata[I] = data[I];
// }
// for(I=length;I<newlength;I++)
// {
// newdata[I] = T();
// }
if(data!=NULL) {delete[] data; data=NULL;}
data = newdata;
length = newlength;
ret = narray_success;
return ret;
}
template<typename T> narray<T>::narray(const narray<T>& other)
{
narray_size_t I;
int res;
length = 0;
data = NULL;
narray_size_t ml;
//printf("debug: copy constructor called for\n\t%p\n\t%p\n", this, &other);
if(this!=&other)
{
res = this->resize(other.length);
if(res!=narray_success)
{
return;
}
else
{
//threaded copy for speed
ml = (length<other.length) ? length : other.length;
buffer_copycast<T,T>(data,other.data,ml);
// for(I=0;I<length && I<other.length;I++)
// {
// data[I] = other.data[I];
// }
}
}
}
template<typename T> narray<T>::narray(narray<T>&& other) noexcept
{
//this is a move operator
//I still need to understand when these are called.
//printf("debug: move constructor called for\n\t%p\n\t%p\n", this, &other);
//steal the resources from other and reset other to prevent double deletion
length = other.length;
data = other.data;
other.length = 0;
other.data = NULL;
return;
}
template<typename T> narray<T>& narray<T>::operator=(narray<T>&& other) noexcept
{
//printf("debug: move= called for\n\t%p\n\t%p\n", this, &other);
if(this!=&other)
{
if(data!=NULL) {delete[] data; data=NULL;}
length = other.length;
data = other.data;
other.length = 0;
other.data = NULL;
}
return *this;
}
template<typename T> narray<T>& narray<T>::operator=(const narray<T>& other)
{
narray_size_t I;
int res;
narray_size_t ml;
//printf("debug: operator= called for\n\t%p\n\t%p\n", this, &other);
if(this!=&other)
{
res = this->resize(other.length);
if(res!=narray_success)
{
return *this;
}
else
{
//threaded copy for speed
ml = (length<other.length) ? length : other.length;
buffer_copycast<T,T>(data,other.data,ml);
// for(I=0;I<length && I<other.length;I++)
// {
// data[I] = other.data[I];
// }
}
}
return *this;
}
template<typename T> narray<T>& narray<T>::operator=(const std::vector<T>& other)
{
narray_size_t I;
int res;
if(this!=&other)
{
res = this->resize(other.size());
if(res!=narray_success)
{
return *this;
}
else
{
for(I=0;I<length && I<other.size();I++)
{
data[I] = other[I];
}
}
}
return *this;
}
template<typename T> narray<T>::narray(const std::initializer_list<T> initlist)
{
narray_size_t I;
int res;
length = 0;
data = NULL;
res = this->resize(initlist.size());
if(res!=narray_success)
{
return;
}
else
{
I = 0;
for(T elem : initlist)
{
data[I] = elem;
if(I<length) I++;
}
}
}
template<typename T> narray<T>& narray<T>::operator=(const std::initializer_list<T> initlist)
{
narray_size_t I;
int res;
res = this->resize(initlist.size());
if(res!=narray_success)
{
this->length = 0;
if(this->data != NULL) {delete[] this->data; this->data=NULL;}
return *this;
}
else
{
I = 0;
for(T elem : initlist)
{
data[I] = elem;
if(I<length) I++;
}
}
return *this;
}
template<class T> template<class T2> narray<T>::operator narray<T2>() const
{
//casting datatypes
narray<T2> ret;
int res;
res = ret.resize(this->length);
if(res!=narray_success)
{
ret.resize(0);
return ret;
}
else
{
buffer_copycast<T2,T>(ret.data,data,length);
}
return ret;
}
template<typename T> narray<T>::~narray()
{
//printf("debug: destructor called for %p\n",this);
length = 0;
if(data!=NULL) {delete[] data; data=NULL;}
return;
}
template<typename T> T& narray<T>::operator[](const narray_size_t ind)
{
return data[ind];
}
template<typename T> const T& narray<T>::operator[](const narray_size_t ind) const
{
return data[ind];
}
template<typename T> T& narray<T>::at(const narray_size_t ind)
{
return data[ind];
}
template<typename T> const T& narray<T>::at(const narray_size_t ind) const
{
return data[ind];
}
template<typename T> void narray<T>::clear()
{
this->resize(0);
return;
}
template<typename T> void narray_setall_tf(narray<T> *q, const T& val, int threadnum, int nthreads)
{
int I0,I1,Is,I;
Is = q->length/nthreads;
I0 = Is*threadnum;
I1 = (threadnum>=(nthreads-1))? q->length: Is*(threadnum+1);
for(I=I0;I<I1;I++)
{
q->data[I] = val;
}
return;
}
template<typename T> void narray<T>::setall(const T& val)
{
narray_size_t I;
int J;
int nthreads;
std::vector<std::thread*> threads;
if(length<narray_thread_sz)
{
for(I=0;I<length;I++) data[I] = val;
}
else
{
//threaded operation
nthreads = std::thread::hardware_concurrency();
if(nthreads<1) nthreads=1;
if(nthreads>narray_max_threads) nthreads = narray_max_threads;
threads.resize(nthreads);
for(J=0;J<nthreads;J++)
{
threads[J] = new(std::nothrow) std::thread(
&narray_setall_tf<T>,this,val,J,nthreads
);
}
for(J=0;J<nthreads;J++)
{
if(threads[J]!=NULL)
{
threads[J]->join();
delete threads[J];
threads[J]= NULL;
}
}
}
return;
}
template<typename T> const narray_size_t narray<T>::size() const
{
return length;
}
//inserts a value at (before) index ind
//insert(0,val) would give {val, oldval0, oldval1, ...}
//insert(N,val)
template<typename T> int narray<T>::insert(const narray_size_t ind, const T val)
{
int ret = narray_success;
int res;
narray<T> narr;
narray_size_t I;
if(ind<0)
{
ret = narray_failure;
return ret;
}
else if(ind<=this->length)
{
res = narr.resize(this->length+1);
if(res!=narray_success)
{
ret = narray_failure;
return ret;
}
if(this->data!=NULL)
{
for(I=0;I<ind && I<this->length;I++)
{
narr.data[I] = this->data[I];
}
}
narr.data[ind] = val;
if(this->data!=NULL)
{
for(I=ind+1;I<narr.length;I++)
{
narr.data[I] = this->data[I-1];
}
}
//steal data from narr
if(this->data!=NULL) {delete[] this->data; this->data=NULL;}
this->length = narr.length;
this->data = narr.data;
narr.length = 0;
narr.data = NULL;
}
else
{
//inserting past the end of the array
res = narr.resize(ind+1);
if(res!=narray_success)
{
ret = narray_failure;
return ret;
}
if(this->data!=NULL)
{
for(I=0;I<this->length;I++)
{
narr.data[I] = this->data[I];
}
}
narr.data[ind] = val;
//steal data from narr
if(this->data!=NULL) {delete[] this->data; this->data=NULL;}
this->length = narr.length;
this->data = narr.data;
narr.length = 0;
narr.data = NULL;
}
return ret;
}
//removes the value at index ind, and reduces array size by 1
template<typename T> int narray<T>::erase(const narray_size_t ind)
{
int ret = narray_success;
int res;
narray<T> narr;
narray_size_t I;
if(ind<0 || ind>=this->length)
{
ret = narray_failure;
return ret;
}
res = narr.resize(this->length-1);
if(res!=narray_success)
{
ret = narray_failure;
return ret;
}
if(this->data!=NULL)
{
for(I=0;I<ind && I<this->length && I<narr.length;I++)
{
narr.data[I] = this->data[I];
}
for(I=ind+1;I<this->length && (I-1)<narr.length;I++)
{
narr.data[I-1] = this->data[I];
}
}
//steal data from narr (should be similar to what std::move would do?)
if(this->data!=NULL) {delete[] this->data; this->data=NULL;}
this->length = narr.length;
this->data = narr.data;
narr.length = 0;
narr.data = NULL;
return ret;
}
//finds the first instance of val in the array
template<typename T> narray_size_t narray<T>::find(const T val)
{
narray_size_t ret = -1;
narray_size_t I;
for(I=0;I<this->length;I++)
{
if(this->data[I]==val)
{
ret = I;
break;
}
}
return ret;
}
//finds the next instance of val, starting consideration at indstart
template<typename T> narray_size_t narray<T>::findnext(const narray_size_t indstart, const T val)
{
narray_size_t ret = -1;
narray_size_t I;
for(I=indstart;I<this->length;I++)
{
if(this->data[I]==val)
{
ret = I;
break;
}
}
return ret;
}
//finds where to insert a particular value such that the list remains ordered
template<typename T> narray_size_t narray<T>::find_insert_ordered(const T val)
{
narray_size_t ret = -1;
narray_size_t I;
ret = 0;
for(I=0;I<this->length;I++)
{
ret = I+1;
if(this->data[I]>val)
{
ret = I;
break;
}
}
ret = (ret<0) ? 0 : ret;
ret = (ret>this->length) ? this->length : ret;
return ret;
}
}; //end namespace narray
}; //end namespace ams
#endif