KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

taken over container

Browse Source
This commit is contained in:
Robin Müller 2020-10-01 20:31:30 +02:00
parent 26454356f8
commit 0714dc6e06
2 changed files with 243 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
container/FixedOrderedMultimap.h
View File

@ -5,120 +5,200 @@
#include <cstring> #include <cstring>
/** /**
* @brief Map implementation which allows entries with identical keys * @brief An associative container which allows multiple entries of the same key.
* @details * @details
* Performs no dynamic memory allocation except on initialization. * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
* Uses an ArrayList as the underlying container and thus has a linear *
* It uses the ArrayList, so technically this is not a real map, it is an array of pairs
* of type key_t, T. It is ordered by key_t as FixedMap but allows same keys. Thus it has a linear
* complexity O(n). As long as the number of entries remains low, this * complexity O(n). As long as the number of entries remains low, this
* should not be an issue. * should not be an issue.
* The number of insertion and deletion operation should be minimized * The number of insertion and deletion operation should be minimized
* as those incur exensive memory move operations (the underlying container * as those incur extensive memory move operations (the underlying container
* is not node based). * is not node based).
* @ingroup container *
* Its of fixed size so no allocations are performed after the construction.
*
* The maximum size is given as first parameter of the constructor.
*
* It provides an iterator to do list iterations.
*
* The type T must have a copy constructor if it is not trivial copy-able.
*
* @warning Iterators return a non-const key_t in the pair.
* @warning A User is not allowed to change the key, otherwise the map is corrupted.
*
* \ingroup container
*/ */
template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>> template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
class FixedOrderedMultimap { class FixedOrderedMultimap {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP; static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01); static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02); static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
/***
* Constructor which needs a size_t for the maximum allowed size
*
* Can not be resized during runtime
*
* Allocates memory at construction
* @param maxSize size_t of Maximum allowed size
*/
FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
}
/***
* Virtual destructor frees Memory by deleting its member
*/
virtual ~FixedOrderedMultimap() {
}
/***
* Special iterator for FixedOrderedMultimap
*/
class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
public:
Iterator() :
ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
}
Iterator(std::pair<key_t, T> *pair) :
ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
}
};
/***
* Returns an iterator pointing to the first element
* @return Iterator pointing to first element
*/
Iterator begin() const {
return Iterator(&theMap[0]);
}
/** /**
* Initializes the ordered multimap with a fixed maximum size. * Returns an iterator pointing to one element past the end
* @param maxSize * @return Iterator pointing to one element past the end
*/ */
FixedOrderedMultimap(size_t maxSize); Iterator end() const {
return Iterator(&theMap[_size]);
}
virtual ~FixedOrderedMultimap() {} /***
* Returns the current size of the map (not maximum size!)
* @return Current size
*/
size_t size() const{
return _size;
}
class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator { /**
public: * Clears the map, does not deallocate any memory
/** Returns an iterator to nullptr */ */
Iterator(); void clear(){
/** Initializes iterator to given entry */ _size = 0;
Iterator(std::pair<key_t, T> *pair); }
};
/** Iterator to start of map */ /**
Iterator begin() const; * Returns the maximum size of the map
/** Iterator to end of map */ * @return Maximum size of the map
Iterator end() const; */
/** Current (variable) size of the map */ size_t maxSize() const{
size_t size() const; return theMap.maxSize();
}
/** /***
* Insert a key/value pair inside the map. An iterator to the stored * Used to insert a key and value separately.
* value might be returned optionally. *
* @param key * @param[in] key Key of the new element
* @param value * @param[in] value Value of the new element
* @param storedValue * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
* @return * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
*/ */
ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr); ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
/**
* Insert a given std::pair<key, value>
* @param pair
* @return
*/
ReturnValue_t insert(std::pair<key_t, T> pair);
/**
* Checks existence of key in map.
* @param key
* @return
* - @c KEY_DOES_NOT_EXIST if key does not exists.
* - @c RETURN_OK otherwise.
*/
ReturnValue_t exists(key_t key) const;
ReturnValue_t erase(Iterator *iter); /***
ReturnValue_t erase(key_t key); * Used to insert new pair instead of single values
*
* @param pair Pair to be inserted
* @return RETURN_OK if insert was successful, MAP_FULL if no space is available
*/
ReturnValue_t insert(std::pair<key_t, T> pair);
Iterator find(key_t key) const; /***
ReturnValue_t find(key_t key, T **value) const; * Can be used to check if a certain key is in the map
* @param key Key to be checked
* @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
*/
ReturnValue_t exists(key_t key) const;
void clear(); /***
* Used to delete the element in the iterator
*
* The iterator will point to the element before or begin(),
* but never to one element in front of the map.
*
* @warning The iterator needs to be valid and dereferenceable
* @param[in/out] iter Pointer to iterator to the element that needs to be ereased
* @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
*/
ReturnValue_t erase(Iterator *iter);
size_t maxSize() const; /***
* Used to erase by key
* @param key Key to be erased
* @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
*/
ReturnValue_t erase(key_t key);
/***
* Find returns the first appearance of the key
*
* If the key does not exist, it points to end()
*
* @param key Key to search for
* @return Iterator pointing to the first entry of key
*/
Iterator find(key_t key) const{
ReturnValue_t result = exists(key);
if (result != HasReturnvaluesIF::RETURN_OK) {
return end();
}
return Iterator(&theMap[findFirstIndex(key)]);
};
/***
* Finds first entry of the given key and returns a
* pointer to the value
*
* @param key Key to search for
* @param value Found value
* @return RETURN_OK if it points to the value,
* KEY_DOES_NOT_EXIST if the key is not in the map
*/
ReturnValue_t find(key_t key, T **value) const;
friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
const typename FixedOrderedMultimap::Iterator& rhs) {
return (lhs.value == rhs.value);
}
friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
const typename FixedOrderedMultimap::Iterator& rhs) {
return not (lhs.value == rhs.value);
}
private: private:
typedef KEY_COMPARE compare; typedef KEY_COMPARE compare;
compare myComp; compare myComp;
ArrayList<std::pair<key_t, T>, uint32_t> theMap; ArrayList<std::pair<key_t, T>, size_t> theMap;
size_t _size; size_t _size;
uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const { size_t findFirstIndex(key_t key, size_t startAt = 0) const;
if (startAt >= _size) {
return startAt + 1;
}
uint32_t i = startAt;
for (i = startAt; i < _size; ++i) {
if (theMap[i].first == key) {
return i;
}
}
return i;
}
uint32_t findNicePlace(key_t key) const { size_t findNicePlace(key_t key) const;
uint32_t i = 0;
for (i = 0; i < _size; ++i) {
if (myComp(key, theMap[i].first)) {
return i;
}
}
return i;
}
void removeFromPosition(uint32_t position) { void removeFromPosition(size_t position);
if (_size <= position) {
return;
}
std::memmove(static_cast<void*>(&theMap[position]),
static_cast<void*>(&theMap[position + 1]),
(_size - position - 1) * sizeof(std::pair<key_t,T>));
--_size;
}
}; };
#include "FixedOrderedMultimap.tpp" #include "FixedOrderedMultimap.tpp"

190
container/FixedOrderedMultimap.tpp
View File

@ -1,142 +1,108 @@
#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
template<typename key_t, typename T, typename KEY_COMPARE>
inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator( inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
std::pair<key_t, T> *pair): if (_size == theMap.maxSize()) {
ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){} return MAP_FULL;
}
size_t position = findNicePlace(key);
memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
(_size - position) * sizeof(std::pair<key_t,T>));
theMap[position].first = key;
theMap[position].second = value;
++_size;
if (storedValue != nullptr) {
*storedValue = Iterator(&theMap[position]);
}
return HasReturnvaluesIF::RETURN_OK;
}
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const { return insert(pair.first, pair.second);
return Iterator(&theMap[0]);
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const { ReturnValue_t result = KEY_DOES_NOT_EXIST;
return Iterator(&theMap[_size]); if (findFirstIndex(key) < _size) {
} result = HasReturnvaluesIF::RETURN_OK;
}
return result;
template<typename key_t, typename T, typename KEY_COMPARE>
inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
return _size;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap( inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
size_t maxSize): theMap(maxSize), _size(0) {} size_t i;
if ((i = findFirstIndex((*iter).value->first)) >= _size) {
return KEY_DOES_NOT_EXIST;
template<typename key_t, typename T, typename KEY_COMPARE> }
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert( removeFromPosition(i);
key_t key, T value, Iterator *storedValue) { if (*iter != begin()) {
if (_size == theMap.maxSize()) { (*iter)--;
return MAP_FULL; } else {
} *iter = begin();
uint32_t position = findNicePlace(key); }
// Compiler might emitt warning because std::pair is not a POD type (yet..) return HasReturnvaluesIF::RETURN_OK;
// See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
// Circumvent warning by casting to void*
std::memmove(static_cast<void*>(&theMap[position + 1]),
static_cast<void*>(&theMap[position]),
(_size - position) * sizeof(std::pair<key_t,T>));
theMap[position].first = key;
theMap[position].second = value;
++_size;
if (storedValue != nullptr) {
*storedValue = Iterator(&theMap[position]);
}
return HasReturnvaluesIF::RETURN_OK;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert( inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
std::pair<key_t, T> pair) { size_t i;
return insert(pair.fist, pair.second); if ((i = findFirstIndex(key)) >= _size) {
return KEY_DOES_NOT_EXIST;
}
do {
removeFromPosition(i);
i = findFirstIndex(key, i);
} while (i < _size);
return HasReturnvaluesIF::RETURN_OK;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists( inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
key_t key) const { ReturnValue_t result = exists(key);
ReturnValue_t result = KEY_DOES_NOT_EXIST; if (result != HasReturnvaluesIF::RETURN_OK) {
if (findFirstIndex(key) < _size) { return result;
result = HasReturnvaluesIF::RETURN_OK; }
} *value = &theMap[findFirstIndex(key)].second;
return result; return HasReturnvaluesIF::RETURN_OK;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase( inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
Iterator *iter) if (startAt >= _size) {
{ return startAt + 1;
uint32_t i; }
if ((i = findFirstIndex((*iter).value->first)) >= _size) { size_t i = startAt;
return KEY_DOES_NOT_EXIST; for (i = startAt; i < _size; ++i) {
} if (theMap[i].first == key) {
removeFromPosition(i); return i;
if (*iter != begin()) { }
(*iter)--; }
} else { return i;
*iter = begin();
}
return HasReturnvaluesIF::RETURN_OK;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase( inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
key_t key) size_t i = 0;
{ for (i = 0; i < _size; ++i) {
uint32_t i; if (myComp(key, theMap[i].first)) {
if ((i = findFirstIndex(key)) >= _size) { return i;
return KEY_DOES_NOT_EXIST; }
} }
do { return i;
removeFromPosition(i);
i = findFirstIndex(key, i);
} while (i < _size);
return HasReturnvaluesIF::RETURN_OK;
} }
template<typename key_t, typename T, typename KEY_COMPARE> template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find( inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
key_t key, T **value) const if (_size <= position) {
{ return;
ReturnValue_t result = exists(key); }
if (result != HasReturnvaluesIF::RETURN_OK) { memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
return result; (_size - position - 1) * sizeof(std::pair<key_t,T>));
} --_size;
*value = &theMap[findFirstIndex(key)].second;
return HasReturnvaluesIF::RETURN_OK;
}
template<typename key_t, typename T, typename KEY_COMPARE>
inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
key_t key) const
{
ReturnValue_t result = exists(key);
if (result != HasReturnvaluesIF::RETURN_OK) {
return end();
}
return Iterator(&theMap[findFirstIndex(key)]);
}
template<typename key_t, typename T, typename KEY_COMPARE>
inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
{
_size = 0;
}
template<typename key_t, typename T, typename KEY_COMPARE>
inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
{
return theMap.maxSize();
} }