Merge branch 'master' into gaisser_fifobase_nullptr_check
This commit is contained in:
commit
6c4ec713f3
|
|
@ -3,26 +3,62 @@
|
|||
|
||||
#include "../storagemanager/StorageManagerIF.h"
|
||||
#include <utility>
|
||||
|
||||
/**
|
||||
* The Placement Factory is used to create objects at runtime in a specific pool.
|
||||
* In general, this should be avoided and it should only be used if you know what you are doing.
|
||||
* You are not allowed to use this container with a type that allocates memory internally like ArrayList.
|
||||
*
|
||||
* Also, you have to check the returned pointer in generate against nullptr!
|
||||
*
|
||||
* A backend of Type StorageManagerIF must be given as a place to store the new objects.
|
||||
* Therefore ThreadSafety is only provided by your StorageManager Implementation.
|
||||
*
|
||||
* Objects must be destroyed by the user with "destroy"! Otherwise the pool will not be cleared.
|
||||
*
|
||||
* The concept is based on the placement new operator.
|
||||
*
|
||||
* @warning Do not use with any Type that allocates memory internally!
|
||||
* @ingroup container
|
||||
*/
|
||||
class PlacementFactory {
|
||||
public:
|
||||
PlacementFactory(StorageManagerIF* backend) :
|
||||
dataBackend(backend) {
|
||||
}
|
||||
|
||||
/***
|
||||
* Generates an object of type T in the backend storage.
|
||||
*
|
||||
* @warning Do not use with any Type that allocates memory internally!
|
||||
*
|
||||
* @tparam T Type of Object
|
||||
* @param args Constructor Arguments to be passed
|
||||
* @return A pointer to the new object or a nullptr in case of failure
|
||||
*/
|
||||
template<typename T, typename ... Args>
|
||||
T* generate(Args&&... args) {
|
||||
store_address_t tempId;
|
||||
uint8_t* pData = NULL;
|
||||
uint8_t* pData = nullptr;
|
||||
ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
|
||||
&pData);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
T* temp = new (pData) T(std::forward<Args>(args)...);
|
||||
return temp;
|
||||
}
|
||||
/***
|
||||
* Function to destroy the object allocated with generate and free space in backend.
|
||||
* This must be called by the user.
|
||||
*
|
||||
* @param thisElement Element to be destroyed
|
||||
* @return RETURN_OK if the element was destroyed, different errors on failure
|
||||
*/
|
||||
template<typename T>
|
||||
ReturnValue_t destroy(T* thisElement) {
|
||||
if (thisElement == nullptr){
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
|
||||
thisElement->~T();
|
||||
uint8_t* pointer = (uint8_t*) (thisElement);
|
||||
|
|
|
|||
|
|
@ -1,79 +0,0 @@
|
|||
|
||||
#include <iostream>
|
||||
#include "SimpleRingBuffer.h"
|
||||
|
||||
|
||||
int main() {
|
||||
using namespace std;
|
||||
SimpleRingBuffer buffer(64, false);
|
||||
uint8_t data[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
|
||||
ReturnValue_t result = buffer.writeData(data, 8);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
result = buffer.writeData(data, 8);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
uint8_t buffer2[47] = {0};
|
||||
for (uint8_t count = 0; count<sizeof(buffer2); count++) {
|
||||
buffer2[count] = count;
|
||||
}
|
||||
result = buffer.writeData(buffer2, sizeof(buffer2));
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
result = buffer.writeData(buffer2, sizeof(buffer2));
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
uint8_t readBuffer[64] = {0};
|
||||
uint32_t writtenData = 0;
|
||||
result = buffer.readData(readBuffer, 12, true, &writtenData);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "readData failed." << endl;
|
||||
} else {
|
||||
cout << "Read data: " << writtenData << endl;
|
||||
for (uint32_t count = 0; count < writtenData; count++) {
|
||||
cout << hex << (uint16_t)readBuffer[count] << " ";
|
||||
}
|
||||
cout << dec << endl;
|
||||
}
|
||||
|
||||
result = buffer.readData(readBuffer, 60, true, &writtenData);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "readData failed." << endl;
|
||||
} else {
|
||||
cout << "Read data: " << writtenData << endl;
|
||||
for (uint32_t count = 0; count < writtenData; count++) {
|
||||
cout << hex << (uint16_t)readBuffer[count] << " ";
|
||||
}
|
||||
cout << dec << endl;
|
||||
}
|
||||
result = buffer.writeData(data, sizeof(data));
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
result = buffer.readData(readBuffer, 60, true, &writtenData);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "readData failed." << endl;
|
||||
} else {
|
||||
cout << "Read data: " << writtenData << endl;
|
||||
for (uint32_t count = 0; count < writtenData; count++) {
|
||||
cout << hex << (uint16_t)readBuffer[count] << " ";
|
||||
}
|
||||
cout << dec << endl;
|
||||
}
|
||||
result = buffer.writeData(readBuffer, sizeof(readBuffer));
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
}
|
||||
result = buffer.writeData(readBuffer, sizeof(readBuffer)-1);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
cout << "writeData failed." << endl;
|
||||
} else {
|
||||
cout << "write done." << endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,365 +0,0 @@
|
|||
#include "FixedArrayList.h"
|
||||
#include "SinglyLinkedList.h"
|
||||
#include "HybridIterator.h"
|
||||
|
||||
#include "FixedMap.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
|
||||
class Packet: public SinglyLinkedList {
|
||||
public:
|
||||
SinglyLinkedList::Element<uint32_t> element1;
|
||||
SinglyLinkedList::Element<uint32_t> element2;
|
||||
|
||||
Packet() {
|
||||
this->start = &element1;
|
||||
element1.next = &element2;
|
||||
}
|
||||
};
|
||||
|
||||
class Packet2: public SinglyLinkedList {
|
||||
public:
|
||||
SinglyLinkedList::Element<uint32_t> element1;
|
||||
SinglyLinkedList::Element<FixedArrayList<FixedArrayList<uint8_t, 5>, 2>> element2;
|
||||
SinglyLinkedList::Element<uint32_t> element3;
|
||||
|
||||
Packet2() {
|
||||
this->start = &element1;
|
||||
element1.next = &element2;
|
||||
element2.next = &element3;
|
||||
}
|
||||
};
|
||||
|
||||
class Packet3: public SinglyLinkedList {
|
||||
public:
|
||||
SinglyLinkedList::TypedElement<uint32_t> element1;
|
||||
SinglyLinkedList::TypedElement<uint32_t> element2;
|
||||
|
||||
Packet3() {
|
||||
this->start = &element1;
|
||||
element1.next = &element2;
|
||||
}
|
||||
};
|
||||
|
||||
void arrayList() {
|
||||
puts("** Array List **");
|
||||
FixedArrayList<uint32_t, 10, uint32_t> list;
|
||||
FixedArrayList<uint32_t, 10, uint32_t> list2;
|
||||
|
||||
list.size = 2;
|
||||
|
||||
list[0] = 0xcafecafe;
|
||||
|
||||
list[1] = 0x12345678;
|
||||
|
||||
uint8_t buffer[100];
|
||||
uint8_t *pointer = buffer;
|
||||
uint32_t size = 0;
|
||||
uint32_t maxSize = 100;
|
||||
uint32_t i;
|
||||
int32_t size2;
|
||||
|
||||
printf("printsize: %i\n", list.getPrintSize());
|
||||
|
||||
list.print(&pointer, &size, 100, true);
|
||||
|
||||
printf("buffer(%i):", size);
|
||||
for (i = 0; i < size; ++i) {
|
||||
printf("%02x", buffer[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
pointer = buffer;
|
||||
|
||||
size2 = size;
|
||||
|
||||
printf("list2 read: %x\n", list2.read(&pointer, &size2, true));
|
||||
|
||||
printf("list2(%i):", list2.size);
|
||||
for (ArrayList<uint32_t, uint32_t>::Iterator iter = list2.begin();
|
||||
iter != list2.end(); iter++) {
|
||||
printf("0x%04x ", *iter);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
HybridIterator<uint32_t, uint32_t> hiter(list.begin(),list.end());
|
||||
|
||||
printf("hybrid1: 0x%04x\n", *(hiter++));
|
||||
printf("hybrid2: 0x%04x\n", *hiter);
|
||||
|
||||
}
|
||||
|
||||
void allocatingList() {
|
||||
puts("** Allocating List **");
|
||||
ArrayList<uint8_t> myList(3), myList2(2);
|
||||
myList[0] = 0xab;
|
||||
myList[1] = 0xcd;
|
||||
myList.size = 2;
|
||||
|
||||
uint8_t buffer[100];
|
||||
uint8_t *pointer = buffer;
|
||||
uint32_t size = 0;
|
||||
uint32_t maxSize = 100;
|
||||
uint32_t i;
|
||||
int32_t size2;
|
||||
|
||||
myList.print(&pointer, &size, 100, true);
|
||||
|
||||
pointer = buffer;
|
||||
size2 = size;
|
||||
|
||||
printf("Read %x\n", myList2.read(&pointer, &size2, true));
|
||||
|
||||
printf("%x,%x\n", myList2[0], myList2[1]);
|
||||
|
||||
}
|
||||
|
||||
void linkedList() {
|
||||
puts("** Linked List **");
|
||||
uint8_t buffer[100];
|
||||
uint8_t *pointer = buffer;
|
||||
uint32_t size = 0;
|
||||
uint32_t maxSize = 100;
|
||||
uint32_t i;
|
||||
int32_t size2;
|
||||
|
||||
Packet myPacket;
|
||||
myPacket.element1.entry = 0x12345678;
|
||||
myPacket.element2.entry = 0x9abcdef0;
|
||||
|
||||
pointer = buffer;
|
||||
size = 0;
|
||||
ReturnValue_t result = myPacket.print(&pointer, &size, 100, true);
|
||||
|
||||
printf("result %02x\n", result);
|
||||
|
||||
printf("printsize: %i\n", myPacket.getPrintSize());
|
||||
|
||||
printf("buffer(%i):", size);
|
||||
for (i = 0; i < size; ++i) {
|
||||
printf("%02x", buffer[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
Packet3 myPacket3;
|
||||
|
||||
myPacket3.element1.entry = 0x12345678;
|
||||
myPacket3.element2.entry = 0xabcdeff;
|
||||
|
||||
SinglyLinkedList::TypedIterator<uint32_t> titer(&myPacket3.element1);
|
||||
|
||||
printf("0x%04x\n", *titer);
|
||||
|
||||
HybridIterator<uint32_t, uint32_t> hiter(&myPacket3.element1);
|
||||
|
||||
printf("hybrid1: 0x%04x\n", *hiter);
|
||||
hiter++;
|
||||
printf("hybrid2: 0x%04x\n", *hiter);
|
||||
}
|
||||
|
||||
void complex() {
|
||||
puts("** complex **");
|
||||
uint8_t buffer[100];
|
||||
uint8_t *pointer = buffer;
|
||||
uint32_t size = 0;
|
||||
uint32_t maxSize = 100;
|
||||
uint32_t i;
|
||||
int32_t size2 = size;
|
||||
|
||||
Packet myPacket2;
|
||||
|
||||
size2 = size;
|
||||
pointer = buffer;
|
||||
|
||||
myPacket2.read(&pointer, &size2, true);
|
||||
|
||||
printf("packet: 0x%04x, 0x%04x\n", myPacket2.element1.entry,
|
||||
myPacket2.element2.entry);
|
||||
|
||||
buffer[0] = 0x12;
|
||||
buffer[1] = 0x34;
|
||||
buffer[2] = 0x56;
|
||||
buffer[3] = 0x78;
|
||||
buffer[4] = 0x2;
|
||||
buffer[5] = 0x3;
|
||||
buffer[6] = 0xab;
|
||||
buffer[7] = 0xcd;
|
||||
buffer[8] = 0xef;
|
||||
buffer[9] = 0x2;
|
||||
buffer[10] = 0x11;
|
||||
buffer[11] = 0x22;
|
||||
buffer[12] = 0xca;
|
||||
buffer[13] = 0xfe;
|
||||
buffer[14] = 0x5a;
|
||||
buffer[15] = 0xfe;
|
||||
|
||||
pointer = buffer;
|
||||
size2 = 23;
|
||||
|
||||
Packet2 p2;
|
||||
|
||||
ReturnValue_t result = p2.read(&pointer, &size2, true);
|
||||
printf("result is %02x\n", result);
|
||||
|
||||
printf("%04x; %i: %i: %x %x %x; %i: %x %x;; %04x\n", p2.element1.entry,
|
||||
p2.element2.entry.size, p2.element2.entry[0].size,
|
||||
p2.element2.entry[0][0], p2.element2.entry[0][1],
|
||||
p2.element2.entry[0][2], p2.element2.entry[1].size,
|
||||
p2.element2.entry[1][0], p2.element2.entry[1][1],
|
||||
p2.element3.entry);
|
||||
|
||||
}
|
||||
*/
|
||||
struct Test {
|
||||
uint32_t a;
|
||||
uint32_t b;
|
||||
};
|
||||
|
||||
template<typename key_t, typename T>
|
||||
void printMap(FixedMap<key_t, T> *map) {
|
||||
typename FixedMap<key_t, T>::Iterator iter;
|
||||
printf("Map (%i): ", map->getSize());
|
||||
for (iter = map->begin(); iter != map->end(); ++iter) {
|
||||
printf("%x:%08x,%08x ", iter.value->first, (*iter).a, (*iter).b);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void map() {
|
||||
puts("** Map **");
|
||||
typename FixedMap<T, Test>::Iterator iter;
|
||||
ReturnValue_t result;
|
||||
FixedMap<T, Test> myMap(5);
|
||||
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
Test a;
|
||||
a.a = 0x01234567;
|
||||
a.b = 0xabcdef89;
|
||||
|
||||
myMap.insert(1, a);
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
a.a = 0;
|
||||
|
||||
myMap.insert(2, a);
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
printf("2 exists: %x\n", myMap.exists(0x02));
|
||||
|
||||
printf("ff exists: %x\n", myMap.exists(0xff));
|
||||
|
||||
a.a = 1;
|
||||
printf("insert 0x2: %x\n", myMap.insert(2, a));
|
||||
|
||||
result = myMap.insert(0xff, a);
|
||||
a.a = 0x44;
|
||||
result = myMap.insert(0xab, a);
|
||||
result = myMap.insert(0xa, a);
|
||||
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
printf("insert 0x5: %x\n", myMap.insert(5, a));
|
||||
|
||||
printf("erase 0xfe: %x\n", myMap.erase(0xfe));
|
||||
|
||||
printf("erase 0x2: %x\n", myMap.erase(0x2));
|
||||
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
printf("erase 0xab: %x\n", myMap.erase(0xab));
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
printf("insert 0x5: %x\n", myMap.insert(5, a));
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
iter = myMap.begin();
|
||||
++iter;
|
||||
++iter;
|
||||
++iter;
|
||||
|
||||
printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
|
||||
|
||||
myMap.erase(&iter);
|
||||
|
||||
printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
|
||||
printMap<T, Test>(&myMap);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
void mapPrint() {
|
||||
puts("** Map Print **");
|
||||
FixedMap<uint16_t, Packet2> myMap(5);
|
||||
Packet2 myPacket;
|
||||
myPacket.element1.entry = 0x12345678;
|
||||
|
||||
myPacket.element2.entry[0][0] = 0xab;
|
||||
myPacket.element2.entry[0][1] = 0xcd;
|
||||
myPacket.element2.entry[0].size = 2;
|
||||
myPacket.element2.entry.size = 1;
|
||||
|
||||
myPacket.element3.entry = 0xabcdef90;
|
||||
|
||||
myMap.insert(0x1234, myPacket);
|
||||
|
||||
uint8_t buffer[100];
|
||||
uint32_t size = 0, i;
|
||||
uint8_t *pointer = buffer;
|
||||
|
||||
printf("printsize: %i\n", myMap.getPrintSize());
|
||||
|
||||
SerializeAdapter<FixedMap<uint16_t, Packet2>>::print(&myMap, &pointer,
|
||||
&size, 100, false);
|
||||
|
||||
printf("buffer(%i):", size);
|
||||
for (i = 0; i < size; ++i) {
|
||||
printf("%02x", buffer[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
int32_t size2 = size;
|
||||
pointer = buffer;
|
||||
|
||||
FixedMap<uint16_t, Packet2> myMap2(5);
|
||||
|
||||
ReturnValue_t result = SerializeAdapter<FixedMap<uint16_t, Packet2>>::read(
|
||||
&myMap2, &pointer, &size2, false);
|
||||
|
||||
Packet2 *myPacket2 = myMap2.find(0x1234);
|
||||
|
||||
printf("Map (%i): Packet2: %x, Array (%i): Array (%i): %x, %x; %x\n",
|
||||
myMap2.getSize(), myPacket2->element1.entry,
|
||||
myPacket2->element2.entry.size, myPacket2->element2.entry[0].size,
|
||||
myPacket2->element2.entry[0][0], myPacket2->element2.entry[0][1],
|
||||
myPacket2->element3.entry);
|
||||
|
||||
}
|
||||
|
||||
void empty() {
|
||||
puts("** Empty **");
|
||||
ArrayList<uint32_t> list(0);
|
||||
printf("%p %p\n", list.front(), list.back());
|
||||
}
|
||||
*/
|
||||
|
||||
int main(void) {
|
||||
|
||||
// arrayList();
|
||||
// linkedList();
|
||||
// allocatingList();
|
||||
// complex();
|
||||
|
||||
map<uint32_t>();
|
||||
//
|
||||
// mapPrint();
|
||||
|
||||
// empty();
|
||||
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue