132 lines
2.9 KiB
C++
132 lines
2.9 KiB
C++
/************************************************
|
|
* Fixed element pointer position.
|
|
* The current pointer points to the latest element
|
|
*
|
|
* create zoufuzhou 20201001
|
|
*
|
|
************************************************/
|
|
#ifndef _MEM_FIX_ADDR_CACHE_HPP_
|
|
#define _MEM_FIX_ADDR_CACHE_HPP_
|
|
|
|
#include <glob/GlobMem.h>
|
|
|
|
template <typename T>
|
|
class CMemFix {
|
|
typedef struct {
|
|
unsigned int maxsize;
|
|
unsigned int size;
|
|
unsigned int next;
|
|
} HEAD;
|
|
|
|
// Local variable
|
|
private:
|
|
unsigned int m_getnext;
|
|
|
|
// Memory variable
|
|
private:
|
|
HEAD* p_head;
|
|
T* p_ptr;
|
|
|
|
private:
|
|
void init(const string& tableName) {
|
|
char* ptr = (char*)GlobMem::GetInstancePtr()->GetTablePtr(tableName);
|
|
if (ptr == nullptr) {
|
|
p_ptr = nullptr;
|
|
p_head = nullptr;
|
|
|
|
assert(true);
|
|
return;
|
|
}
|
|
p_head = (HEAD*)(ptr);
|
|
p_ptr = (T*)(ptr + sizeof(HEAD));
|
|
};
|
|
|
|
public:
|
|
// memfix get not need set cache maxsize
|
|
CMemFix(const string& tableName) {
|
|
this->init(tableName);
|
|
// assert(p_head->maxsize>1);
|
|
|
|
this->m_getnext = p_head->next;
|
|
};
|
|
|
|
// memfix push need set cache maxsize
|
|
CMemFix(const string& tableName, unsigned int maxsize) {
|
|
// assert(maxsize>1);
|
|
this->init(tableName);
|
|
|
|
p_head->maxsize = maxsize;
|
|
if (p_head->size > p_head->maxsize) {
|
|
p_head->size = p_head->maxsize;
|
|
}
|
|
|
|
if (p_head->next > p_head->maxsize) {
|
|
p_head->next = p_head->maxsize;
|
|
}
|
|
p_head->next = p_head->next % p_head->maxsize;
|
|
|
|
this->m_getnext = p_head->next;
|
|
};
|
|
|
|
~CMemFix(){};
|
|
|
|
T* operator()(void) { return p_ptr; };
|
|
|
|
// Take the next value
|
|
T* getNext() {
|
|
if (this->m_getnext == p_head->next) {
|
|
return nullptr;
|
|
} else {
|
|
unsigned int tmpnext = this->m_getnext;
|
|
this->m_getnext = (this->m_getnext + 1) % this->p_head->maxsize;
|
|
return this->operator[](tmpnext);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// unsigned int get_next() { return this->m_getnext; }
|
|
|
|
// Take the current latest value
|
|
T* getCur(void) { return p_ptr + this->index_cur(); }
|
|
|
|
unsigned int index_cur(void) {
|
|
if (p_head->next <= 0) {
|
|
return this->p_head->maxsize - 1;
|
|
} else {
|
|
return (p_head->next - 1) % this->p_head->maxsize;
|
|
}
|
|
}
|
|
|
|
unsigned int max_size(void) { return this->p_head->maxsize; }
|
|
|
|
T* operator[](unsigned int i) {
|
|
if (p_ptr == nullptr) return nullptr;
|
|
return p_ptr + i;
|
|
};
|
|
|
|
void push(T* t) {
|
|
if (p_ptr == nullptr) return;
|
|
if (p_head->size < this->p_head->maxsize) {
|
|
p_head->size++;
|
|
}
|
|
|
|
memcpy(p_ptr + p_head->next, t, sizeof(T));
|
|
// cout<<"p_next:"<<p_head->next<<endl;
|
|
p_head->next = (p_head->next + 1) % this->p_head->maxsize;
|
|
};
|
|
|
|
unsigned int size(void) {
|
|
if (p_head == nullptr) return 0;
|
|
return p_head->size;
|
|
};
|
|
|
|
void clear(void) {
|
|
if (p_head == nullptr) return;
|
|
p_head->size = 0;
|
|
p_head->next = 0;
|
|
this->m_getnext = p_head->next;
|
|
};
|
|
};
|
|
#endif
|