You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
251 lines
8.6 KiB
251 lines
8.6 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#ifndef hsMemoryDefined |
|
#define hsMemoryDefined |
|
|
|
#include "hsTypes.h" |
|
//#include "hsTemplates.h" |
|
|
|
class HSMemory { |
|
public: |
|
#if HS_BUILD_FOR_MAC |
|
static void BlockMove(const void* src, void* dst, UInt32 length); |
|
#else |
|
static void BlockMove(const void* src, void* dst, UInt32 length); |
|
#endif |
|
static void Clear(void *m, UInt32 byteLen); |
|
static void ClearMemory(void *m, UInt32 byteLen) { HSMemory::Clear(m, byteLen); } |
|
|
|
static hsBool EqualBlocks(const void* block1, const void* block2, UInt32 length); |
|
|
|
static void* New(UInt32 size); |
|
static void Delete(void* block); |
|
static void* Copy(UInt32 length, const void* source); |
|
|
|
static void* SoftNew(UInt32 size); // returns nil if can't allocate |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
class hsAllocator { |
|
public: |
|
virtual void* Alloc(UInt32 size) = 0; |
|
virtual void Free(void* addr) = 0; |
|
}; |
|
|
|
class hsScratchMem { |
|
enum { |
|
kBufferSize = 32 |
|
}; |
|
UInt8* fMem; |
|
UInt8 fMemBuffer[kBufferSize]; |
|
UInt32 fLength; |
|
public: |
|
hsScratchMem() : fLength(kBufferSize) |
|
{ |
|
fMem = fMemBuffer; |
|
} |
|
~hsScratchMem() |
|
{ |
|
if (fMem != fMemBuffer) |
|
delete[] fMem; |
|
} |
|
UInt8* GetMem(UInt32 length) |
|
{ |
|
if (length > fLength) |
|
{ if (fMem != fMemBuffer) |
|
delete[] fMem; |
|
fMem = TRACKED_NEW UInt8[length]; |
|
fLength = length; |
|
} |
|
return fMem; |
|
} |
|
}; |
|
|
|
class hsChunkAllocator { |
|
enum { |
|
kDefaultChunkSize = 4096 |
|
}; |
|
UInt32 fChunkSize; |
|
struct hsPrivateChunk* fChunk; |
|
hsDebugCode(UInt32 fChunkCount;) |
|
public: |
|
hsChunkAllocator(UInt32 chunkSize = kDefaultChunkSize); |
|
~hsChunkAllocator(); |
|
|
|
void Reset(); |
|
void SetChunkSize(UInt32 size); |
|
void* Allocate(UInt32 size, const void* data = nil); // throws if fails |
|
void* SoftAllocate(UInt32 size, const void* data = nil); // returns nil if fails |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
class hsAppender { |
|
struct hsAppenderHead* fFirstBlock, *fLastBlock; |
|
UInt32 fElemSize, fElemCount, fCount; |
|
|
|
friend class hsAppenderIterator; |
|
public: |
|
hsAppender(UInt32 elemSize, UInt32 minCount = 16); |
|
~hsAppender(); |
|
|
|
UInt32 ElemSize() const { return fElemSize; } |
|
UInt32 Count() const { return fCount; } |
|
hsBool IsEmpty() const { return fCount == 0; } |
|
void Reset(); |
|
|
|
UInt32 CopyInto(void* data = nil) const; // return size of data array in bytes |
|
|
|
void* PushHead(); |
|
void PushHead(const void* data); |
|
void* PushTail(); |
|
void PushTail(const void* data); |
|
void PushTail(int count, const void* data); // data[] = count * fElemSize |
|
void* PeekHead() const; |
|
void* PeekTail() const; |
|
hsBool PopHead(void* data = nil); |
|
int PopHead(int count, void* data = nil); // data[] = count * fElemSize |
|
hsBool PopTail(void* data = nil); |
|
|
|
// Alternate interfaces |
|
|
|
void* Prepend() { return this->PushHead(); } |
|
void* Append() { return this->PushTail(); } |
|
|
|
void* Push() { return this->PushHead(); } |
|
void Push(const void* data) { this->PushHead(data); } |
|
hsBool Pop(void* data = nil) { return this->PopHead(data); } |
|
|
|
void* Enqueue() { return this->PushTail(); }; |
|
void Enqueue(const void* data) { this->PushTail(data); } |
|
void Enqueue(int count, const void* data) { this->PushTail(count, data); } |
|
hsBool Dequeue(void* data = nil) { return this->PopHead(data); } |
|
int Dequeue(int count, void* data = nil) { return this->PopHead(count, data); } |
|
}; |
|
|
|
class hsAppenderIterator { |
|
const hsAppender* fAppender; |
|
const struct hsAppenderHead* fCurrBlock; |
|
void* fCurrItem; |
|
public: |
|
hsAppenderIterator(const hsAppender* list = nil); |
|
|
|
void ResetToHead(const hsAppender* list = nil); |
|
void ResetToTail(const hsAppender* list = nil); |
|
void* Next(); |
|
hsBool Next(void* data); |
|
int Next(int count, void* data); |
|
void* Prev(); |
|
hsBool Prev(void* data); |
|
|
|
// Obsolete interface |
|
|
|
void Reset(const hsAppender* list = nil) { this->ResetToHead(list); } |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
|
|
template <class T> class hsTAppender : hsAppender { |
|
public: |
|
hsTAppender() : hsAppender(sizeof(T)) {} |
|
hsTAppender(UInt32 minCount) : hsAppender(sizeof(T), minCount) {} |
|
|
|
hsAppender* GetAppender() { return this; } |
|
const hsAppender* GetAppender() const { return this; } |
|
|
|
UInt32 Count() const { return hsAppender::Count(); } |
|
hsBool IsEmpty() const { return hsAppender::IsEmpty(); } |
|
void Reset() { hsAppender::Reset(); } |
|
|
|
UInt32 CopyInto(T copy[]) const { return hsAppender::CopyInto(copy); } |
|
|
|
T* PushHead() { return (T*)hsAppender::PushHead(); } |
|
void PushHead(const T& item) { *this->PushHead() = item; } |
|
T* PushTail() { return (T*)hsAppender::PushTail(); } |
|
void PushTail(const T& item) { *this->PushTail() = item; }; |
|
void PushTail(int count, const T item[]) { this->hsAppender::PushTail(count, item); }; |
|
T* PeekHead() const { return (T*)hsAppender::PeekHead(); } |
|
T* PeekTail() const { return (T*)hsAppender::PeekTail(); } |
|
hsBool PopHead(T* item = nil) { return hsAppender::PopHead(item); } |
|
int PopHead(int count, T item[] = nil) { return hsAppender::PopHead(count, item); } |
|
hsBool PopTail(T* item = nil) { return hsAppender::PopTail(item); } |
|
|
|
// Alternate intefaces |
|
|
|
T* Prepend() { return this->PushHead(); } |
|
T* Append() { return this->PushTail(); } |
|
void PrependItem(const T& item) { this->PushHead(item); } |
|
void AppendItem(const T& item) { this->PushTail(item); } |
|
|
|
T* Push() { return this->PushHead(); } |
|
void Push(const T& item) { this->PushHead(item); } |
|
hsBool Pop(T* item = nil) { return this->PopHead(item); } |
|
|
|
T* Enqueue() { return this->PushTail(); }; |
|
void Enqueue(const T& item) { this->PushTail(item); } |
|
void Enqueue(int count, const T item[]) { this->PushTail(count, item); } |
|
hsBool Dequeue(T* item = nil) { return this->PopHead(item); } |
|
int Dequeue(int count, T item[] = nil) { return this->PopHead(count, item); } |
|
}; |
|
|
|
template <class T> class hsTAppenderIterator : hsAppenderIterator { |
|
public: |
|
hsTAppenderIterator() : hsAppenderIterator() {} |
|
hsTAppenderIterator(const hsTAppender<T>* list) : hsAppenderIterator(list->GetAppender()) {} |
|
|
|
void ResetToHead() { hsAppenderIterator::ResetToHead(nil); } |
|
void ResetToHead(const hsTAppender<T>* list) { hsAppenderIterator::ResetToHead(list->GetAppender()); } |
|
void ResetToTail() { hsAppenderIterator::ResetToTail(nil); } |
|
void ResetToTail(const hsTAppender<T>* list) { hsAppenderIterator::ResetToTail(list->GetAppender()); } |
|
T* Next() { return (T*)hsAppenderIterator::Next(); } |
|
hsBool Next(T* item) { return hsAppenderIterator::Next(item); } |
|
T* Prev() { return (T*)hsAppenderIterator::Prev(); } |
|
hsBool Prev(T* item) { return hsAppenderIterator::Prev(item); } |
|
|
|
// Obsolete interfaces |
|
|
|
void Reset() { this->ResetToHead(); } |
|
void Reset(const hsTAppender<T>* list) { this->ResetToHead(list); } |
|
}; |
|
#endif |
|
|
|
|