winamp/Src/Wasabi/bfc/memblock.h

102 lines
3.1 KiB
C
Raw Normal View History

2024-09-24 12:54:57 +00:00
#ifndef _MEMBLOCK_H
#define _MEMBLOCK_H
//#include <bfc/wasabi_std.h>
#include <bfc/std_mem.h>
//#include <wasabicfg.h>
#ifdef _DEBUG
extern int memblocks_totalsize;
#endif
class VoidMemBlock {
protected:
VoidMemBlock(int size=0, const void *data=0);
~VoidMemBlock();
void *setSize(int newsize);
void *setMinimumSize(int newminsize, int increment=0);
void *getMemory() const { return mem; }
void setMemory(const void *data, int datalen, int offsetby=0);
int getSize() const;
int isMine(void *ptr);
void zeroMemory();
private:
void *mem;
int size;
};
// just a convenient resizeable block of memory wrapper
// doesn't handle constructors or anything, meant for int, char, etc.
template <class T>
class MemBlock : private VoidMemBlock {
public:
MemBlock(int _size = 0, const T *data = NULL) : VoidMemBlock(_size*sizeof(T), data) {}
MemBlock(const MemBlock<T> &source) : VoidMemBlock(source.getSizeInBytes(), source.getMemory()) {}
MemBlock(const MemBlock<T> *source) : VoidMemBlock(source->getSizeInBytes(), source->getMemory()) {}
T *setSize(int newsize) {
return static_cast<T*>(VoidMemBlock::setSize(newsize * sizeof(T)));
}
T *setMinimumSize(int newminsize, int increment = 0) {
return static_cast<T*>(VoidMemBlock::setMinimumSize(newminsize * sizeof(T), increment*sizeof(T)));
}
T *getMemory() const { return static_cast<T *>(VoidMemBlock::getMemory()); }
T *getMemory(int offset) const { return static_cast<T *>(VoidMemBlock::getMemory())+offset; } // note pointer arithmetic
T *m() const { return getMemory(); }
T *m(int offset) const { return getMemory(offset); }
operator T *() const { return getMemory(); }
T& operator() (unsigned int ofs) { return getMemory()[ofs]; }
const T& operator() (unsigned int ofs) const { return getMemory()[ofs]; }
void copyTo(T *dest) { MEMCPY(getMemory(), dest, getSizeInBytes()); }
int getSize() const { return VoidMemBlock::getSize()/sizeof(T); }// # of T's
int getSizeInBytes() const { return VoidMemBlock::getSize(); }
int isMine(T *ptr) { return VoidMemBlock::isMine(ptr); }
void setMemory(const T *data, int datalen, int offsetby = 0) { VoidMemBlock::setMemory(data, datalen*sizeof(T), offsetby*sizeof(T)); } // # of T's
void zeroMemory() { VoidMemBlock::zeroMemory(); }
void reverse() {
const int nitems = getSize();
if (nitems <= 1) return;
MemBlock<T> nm(this);
T *mymem = getMemory(), *revmem = nm.getMemory();
for (int i = 0, j = nitems-1; j >= 0; i++, j--) {
MEMCPY(mymem+i, revmem+j, sizeof(T));
}
}
};
// just a convenience class for a 2d MemBlock<>
template <class T>
class MemMatrix : public MemBlock<T> {
public:
MemMatrix(int _width, int height, const T *data = NULL) : MemBlock<T>(_width * height, data), width(_width) {}
T *setSize(int _width, int height) {
MemBlock<T>::setSize(width * height);
width = _width;
}
// () access i.e. obj(x,y)
T& operator() (unsigned int x, unsigned int y) {
return *MemBlock<T>::m(x + y * width);
}
const T& operator() (unsigned int x, unsigned int y) const {
return *MemBlock<T>::m(x + y * width);
}
private:
int width;
};
#endif