fsfw/container/FixedOrderedMultimap.tpp

#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_


template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
    if (_size == theMap.maxSize()) {
        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>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
    return insert(pair.first, pair.second);
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
    ReturnValue_t result = KEY_DOES_NOT_EXIST;
    if (findFirstIndex(key) < _size) {
        result = HasReturnvaluesIF::RETURN_OK;
    }
    return result;
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
    size_t i;
    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
        return KEY_DOES_NOT_EXIST;
    }
    removeFromPosition(i);
    if (*iter != begin()) {
        (*iter)--;
    } else {
        *iter = begin();
    }
    return HasReturnvaluesIF::RETURN_OK;
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
    size_t i;
    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>
inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
    ReturnValue_t result = exists(key);
    if (result != HasReturnvaluesIF::RETURN_OK) {
        return result;
    }
    *value = &theMap[findFirstIndex(key)].second;
    return HasReturnvaluesIF::RETURN_OK;
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
    if (startAt >= _size) {
        return startAt + 1;
    }
    size_t i = startAt;
    for (i = startAt; i < _size; ++i) {
        if (theMap[i].first == key) {
            return i;
        }
    }
    return i;
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
    size_t i = 0;
    for (i = 0; i < _size; ++i) {
        if (myComp(key, theMap[i].first)) {
            return i;
        }
    }
    return i;
}

template<typename key_t, typename T, typename KEY_COMPARE>
inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
    if (_size <= position) {
        return;
    }
    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
            (_size - position - 1) * sizeof(std::pair<key_t,T>));
    --_size;
}


#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */