typedef int Index;
typedef int Size;
typedef int Pos;
typedef void NoReturn;
typedef bool Result;
template<typename T>
class ArrayList
{
public:
ArrayList(Size);
~ArrayList();
NoReturn Add(T);
NoReturn Remove(T);
NoReturn RemoveAt(Index);
NoReturn Clear();
NoReturn TrimToSize();
Result Contains(T);
Result Equals(ArrayList*);
Pos indexOf(T);
Pos LastIndexOf(T);
T * Reverse();
T * Insert(Index,T);
T At(Index);
Size Count;
Size * Length;
Size Capacity;
Size GetType();
T operator [](Index x);
Result operator ==(ArrayList Array);
private: T * array;
};
template<typename T>
ArrayList<T>::ArrayList(Size size = 255)
{
this->array = new T[size];
this->Count = 0;
this->Length = &Count;
this->Capacity = size;
}
template<typename T>
ArrayList<T>::~ArrayList()
{
delete []array;
array = NULL;
}
template<typename T>
NoReturn ArrayList<T>::Add(T Value)
{
this->array[this->Count] = Value;
this->Count++;
}
template<typename T>
NoReturn ArrayList<T>::Remove(T Value)
{
T * ar = new T[this->Capacity];
int t = 0;
for(Pos i = 0;i<this->Count;i++)
{
if(this->array[i] != Value)
{
ar[t++] = array[i];
}
}
this->Count = t;
delete []array;
array = NULL;
this->array = ar;
}
template<typename T>
NoReturn ArrayList<T>::RemoveAt(Index x)
{
T * ar = new T[this->Capacity];
int t = 0;
for(Pos i = 0;i<this->Count;i++)
{
if(i != x)
{
ar[t++] = array[i];
}
}
this->Count = t;
delete []array;
array = NULL;
this->array = ar;
}
template<typename T>
NoReturn ArrayList<T>::Clear()
{
delete []array;
array = NULL;
T * New = new T[this->Capacity];
this->array = New;
this->Count = 0;
}
template<typename T>
NoReturn ArrayList<T>::TrimToSize()
{
T * temp = new T[this->Count];
for(int i = 0;i<this->Count;i++)
{
temp[i] = array[i];
}
delete []array;
array = NULL;
this->array = temp;
}
template<typename T>
Result ArrayList<T>::Contains(T Value)
{
bool res = false;
for(int i = 0;i<this->Count;i++)
{
if(this->array[i] == Value){res = true;}
}
return res;
}
template<typename T>
Result ArrayList<T>::Equals(ArrayList * Array)
{
bool res = true;
for(int i = 0;i<this->Count;i++)
{
if(this->array[i] != Array->At(i)){res = false;}
}
return res;
}
template<typename T>
Pos ArrayList<T>::indexOf(T Value)
{
int i;
for(i = 0;i<this->Count;i++)
{
if(this->array[i] == Value){break;}
}
return i;
}
template<typename T>
Pos ArrayList<T>::LastIndexOf(T Value)
{
int i;
for(i = this->Count;i>0;i--)
{
if(this->array[i] == Value){break;}
}
return i;
}
template<typename T>
T * ArrayList<T>::Reverse()
{
T * temp = new T[this->Capacity];
Size t = 0;
for(Pos i = this->Count-1;i>=0;i--)
{
temp[t] = this->array[i];
t++;
}
delete []array;
array = NULL;
this->array = temp;
return this->array;
}
template<typename T>
T * ArrayList<T>::Insert(int Index,T Value)
{
T * temp = new T[this->Capacity];
Pos i = 0;
for(i = 0;i<this->Count+1;i++)
{
if(i < Index)
{
temp[i] = array[i];
}
if(i > Index)
{
temp[i] = array[i-1];
}
}
if(Index > this->Count)
{
temp[this->Count] = Value;
}else if(Index < 0 && Index != -1 && Index != -2)
{
temp[0] = Value;
}
else{
temp[Index] = Value;
}
delete []array;
array = NULL;
this->array = temp;
this->Count++;
return this->array;
}
template<typename T>
T ArrayList<T>::At(int Index)
{
if(Index <= this->Count && Index >= 0)
return this->array[Index];
else
return false;
}
template<typename T>
Size ArrayList<T>::GetType(){return sizeof(T);}
template<typename T>
Result ArrayList<T>::operator ==(ArrayList Array)
{
if(Array.Count == this->Count)
{
for(Pos i = 0;i<Array.Count;i++)
{
if(array[i] != Array[i])
{
return false;
break;
}
}
return true;
}
else
{
return false;
}
}
template <typename T>
T ArrayList<T>::operator [](Index x)
{
if(x <= this->Count && x >= 0)
{
return this->array[x];
}
};
typedef void BGWRK;
typedef void* BGPARAM;
typedef int MAXTHREADS;
class Thread
{
class NewThreadEvent
{
public:void (* function)();
public:NewThreadEvent(void (* functions)())
{
this->function = functions;
};
};
class ThreadEventHandler
{
private:
vector<NewThreadEvent> functions;
public:void Send()
{
for(int i = 0;i<(int)(functions.size());i++)
{
NewThreadEvent ref = functions.at(i);
ref.function();
}
}
public:
NewThreadEvent operator += (NewThreadEvent fr){functions.push_back(fr);}
};
public:
HANDLE Handle;
HANDLE EventHandle;
ThreadEventHandler OnWorkEnd;
ThreadEventHandler OnWorkBegin;
};
void ListenToThread(void * param)
{
Thread * thr = (Thread*)param;
WaitForSingleObject(thr->Handle,INFINITE);
thr->OnWorkEnd.Send();
}
class BackgroundWorker
{
private:
class Works
{
public:
ArrayList<BGWRK (*)(BGWRK*)> Functions;
ArrayList<BGWRK*> Arguments;
void Add(BGWRK (*Func)(BGWRK*),BGWRK * argument)
{
Functions.Add(Func);
Arguments.Add(argument);
};
void Remove(BGWRK (*Func)(BGWRK*))
{
Arguments.RemoveAt(Functions.indexOf(Func));
Functions.Remove(Func);
};
};
LPDWORD ThreadID;
public:
BackgroundWorker(MAXTHREADS);
~BackgroundWorker();
BGWRK DoWork();
BGWRK Suspend();
BGWRK Resume();
BGWRK Abort();
Works Work;
Thread * Threads;
};
BackgroundWorker::BackgroundWorker(MAXTHREADS maxThreads = 99)
{
this->Threads = new Thread[maxThreads];
}
BackgroundWorker::~BackgroundWorker()
{
CloseHandle(this->Threads);
delete[] this->Threads;
}
void BackgroundWorker::DoWork()
{
for(int i = 0;i<this->Work.Functions.Count;i++)
{
this->Threads[i].Handle =
(HANDLE)_beginthreadex
(
NULL,
0,
(unsigned __stdcall int (*)(void*))
Work.Functions.At(i),
Work.Arguments.At(i),
CREATE_SUSPENDED,
(unsigned*)NULL
);
this->Threads[i].EventHandle =
(HANDLE)_beginthreadex
(
NULL,
0,
(unsigned __stdcall int (*)(void*))
ListenToThread,
&this->Threads[i],
CREATE_SUSPENDED,
(unsigned*)NULL
);
}
for(int i = 0;i<this->Work.Functions.Count;i++)
{
ResumeThread(this->Threads[i].Handle);
this->Threads[i].OnWorkBegin.Send();
ResumeThread(this->Threads[i].EventHandle);
}
}
void BackgroundWorker::Suspend()
{
for(int i = 0;i<this->Work.Functions.Count;i++)
{
SuspendThread(this->Threads[i].Handle);
}
}
void BackgroundWorker::Resume()
{
for(int i = 0;i<this->Work.Functions.Count;i++)
{
ResumeThread(this->Threads[i].Handle);
}
}
void BackgroundWorker::Abort()
{
for(int i = 0;i<this->Work.Functions.Count;i++)
{
TerminateThread(this->Threads[i].Handle,0);
}
}