mirror of
https://github.com/hashcat/hashcat.git
synced 2024-12-22 22:58:30 +00:00
192 lines
3.6 KiB
C++
192 lines
3.6 KiB
C++
|
#ifndef _RAR_ARRAY_
|
||
|
#define _RAR_ARRAY_
|
||
|
|
||
|
extern ErrorHandler ErrHandler;
|
||
|
|
||
|
template <class T> class Array
|
||
|
{
|
||
|
private:
|
||
|
T *Buffer;
|
||
|
size_t BufSize;
|
||
|
size_t AllocSize;
|
||
|
size_t MaxSize;
|
||
|
bool Secure; // Clean memory if true.
|
||
|
public:
|
||
|
Array();
|
||
|
Array(size_t Size);
|
||
|
Array(const Array &Src); // Copy constructor.
|
||
|
~Array();
|
||
|
inline void CleanData();
|
||
|
inline T& operator [](size_t Item) const;
|
||
|
inline T* operator + (size_t Pos);
|
||
|
inline size_t Size(); // Returns the size in items, not in bytes.
|
||
|
void Add(size_t Items);
|
||
|
void Alloc(size_t Items);
|
||
|
void Reset();
|
||
|
void SoftReset();
|
||
|
void operator = (Array<T> &Src);
|
||
|
void Push(T Item);
|
||
|
void Append(T *Item,size_t Count);
|
||
|
T* Addr(size_t Item) {return Buffer+Item;}
|
||
|
void SetMaxSize(size_t Size) {MaxSize=Size;}
|
||
|
T* Begin() {return Buffer;}
|
||
|
T* End() {return Buffer==NULL ? NULL:Buffer+BufSize;}
|
||
|
void SetSecure() {Secure=true;}
|
||
|
};
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::CleanData()
|
||
|
{
|
||
|
Buffer=NULL;
|
||
|
BufSize=0;
|
||
|
AllocSize=0;
|
||
|
MaxSize=0;
|
||
|
Secure=false;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> Array<T>::Array()
|
||
|
{
|
||
|
CleanData();
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> Array<T>::Array(size_t Size)
|
||
|
{
|
||
|
CleanData();
|
||
|
Add(Size);
|
||
|
}
|
||
|
|
||
|
|
||
|
// Copy constructor in case we need to pass an object as value.
|
||
|
template <class T> Array<T>::Array(const Array &Src)
|
||
|
{
|
||
|
CleanData();
|
||
|
Alloc(Src.BufSize);
|
||
|
if (Src.BufSize!=0)
|
||
|
memcpy((void *)Buffer,(void *)Src.Buffer,Src.BufSize*sizeof(T));
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> Array<T>::~Array()
|
||
|
{
|
||
|
if (Buffer!=NULL)
|
||
|
{
|
||
|
if (Secure)
|
||
|
cleandata(Buffer,AllocSize*sizeof(T));
|
||
|
free(Buffer);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> inline T& Array<T>::operator [](size_t Item) const
|
||
|
{
|
||
|
return Buffer[Item];
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> inline T* Array<T>::operator +(size_t Pos)
|
||
|
{
|
||
|
return Buffer+Pos;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> inline size_t Array<T>::Size()
|
||
|
{
|
||
|
return BufSize;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::Add(size_t Items)
|
||
|
{
|
||
|
BufSize+=Items;
|
||
|
if (BufSize>AllocSize)
|
||
|
{
|
||
|
if (MaxSize!=0 && BufSize>MaxSize)
|
||
|
{
|
||
|
ErrHandler.GeneralErrMsg(L"Maximum allowed array size (%u) is exceeded",MaxSize);
|
||
|
ErrHandler.MemoryError();
|
||
|
}
|
||
|
|
||
|
size_t Suggested=AllocSize+AllocSize/4+32;
|
||
|
size_t NewSize=Max(BufSize,Suggested);
|
||
|
|
||
|
T *NewBuffer;
|
||
|
if (Secure)
|
||
|
{
|
||
|
NewBuffer=(T *)malloc(NewSize*sizeof(T));
|
||
|
if (NewBuffer==NULL)
|
||
|
ErrHandler.MemoryError();
|
||
|
if (Buffer!=NULL)
|
||
|
{
|
||
|
memcpy(NewBuffer,Buffer,AllocSize*sizeof(T));
|
||
|
cleandata(Buffer,AllocSize*sizeof(T));
|
||
|
free(Buffer);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
NewBuffer=(T *)realloc(Buffer,NewSize*sizeof(T));
|
||
|
if (NewBuffer==NULL)
|
||
|
ErrHandler.MemoryError();
|
||
|
}
|
||
|
Buffer=NewBuffer;
|
||
|
AllocSize=NewSize;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::Alloc(size_t Items)
|
||
|
{
|
||
|
if (Items>AllocSize)
|
||
|
Add(Items-BufSize);
|
||
|
else
|
||
|
BufSize=Items;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::Reset()
|
||
|
{
|
||
|
if (Buffer!=NULL)
|
||
|
{
|
||
|
free(Buffer);
|
||
|
Buffer=NULL;
|
||
|
}
|
||
|
BufSize=0;
|
||
|
AllocSize=0;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Reset buffer size, but preserve already allocated memory if any,
|
||
|
// so we can reuse it without wasting time to allocation.
|
||
|
template <class T> void Array<T>::SoftReset()
|
||
|
{
|
||
|
BufSize=0;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::operator =(Array<T> &Src)
|
||
|
{
|
||
|
Reset();
|
||
|
Alloc(Src.BufSize);
|
||
|
if (Src.BufSize!=0)
|
||
|
memcpy((void *)Buffer,(void *)Src.Buffer,Src.BufSize*sizeof(T));
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::Push(T Item)
|
||
|
{
|
||
|
Add(1);
|
||
|
(*this)[Size()-1]=Item;
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class T> void Array<T>::Append(T *Items,size_t Count)
|
||
|
{
|
||
|
size_t CurSize=Size();
|
||
|
Add(Count);
|
||
|
memcpy(Buffer+CurSize,Items,Count*sizeof(T));
|
||
|
}
|
||
|
|
||
|
#endif
|