cs_Store.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Oct 5, 2021
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
 
#pragma once
 
#include <type_traits>
 
template <class RecordType, unsigned int MaxItemCount>
class Store {
private:
    uint16_t _currentSize = 0;
 
public:
    RecordType _records[MaxItemCount] = {};
 
    RecordType* begin() { return _records; }
 
    RecordType* end() { return _records + _currentSize; }
 
    typedef typename std::remove_reference<decltype(((RecordType*)nullptr)->id())>::type IdType;
 
    void clear() {
        _currentSize = 0;
        for (auto& rec : *this) {
            rec.invalidate();
        }
    }
 
    constexpr RecordType* get(const IdType& id) {
        for (auto& rec : *this) {
            if (rec.isValid() && rec.id() == id) {
                return &rec;
            }
        }
        return nullptr;
    }
 
    template <class UnaryPredicate>
    constexpr RecordType* get(UnaryPredicate p) {
        for (auto& obj : *this) {
            if (p(obj)) {
                return &obj;
            }
        }
        return nullptr;
    }
 
    template <class ValueFunction>
    constexpr RecordType* getMin(ValueFunction getValue) {
        RecordType* smallest = get([](auto rec) { return rec.isValid(); });
 
        if (smallest == nullptr) {
            return nullptr;
        }
 
        for (RecordType* obj = smallest + 1; obj != end(); obj++) {
            if (!obj->isValid()) {
                continue;
            }
 
            if (getValue(*obj) < getValue(*smallest)) {
                smallest = obj;
            }
        }
 
        return smallest;
    }
 
    RecordType* getOrAdd(IdType id) {
        RecordType* retval = nullptr;
        for (auto& rec : *this) {
            if (!rec.isValid()) {
                retval = &rec;
            }
            else if (rec.id() == id) {
                return &rec;
            }
        }
 
        if (retval != nullptr) {
            // not found, but encountered an invalid record in the loop.
            return retval;
        }
 
        return addAtEnd();
    }
 
    constexpr RecordType* add() {
        for (auto& rec : *this) {
            if (!rec.isValid()) {
                return &rec;
            }
        }
        return nullptr;
    }
 
    constexpr RecordType* addAtEnd() {
        if (_currentSize < MaxItemCount) {
            // still have space, increment size and return ref to last index.
            RecordType* retval = &_records[_currentSize++];  // must postcrement
            retval->invalidate();
            return retval;
        }
 
        return nullptr;
    }
 
    uint16_t size() { return _currentSize; }
 
    template <class UnaryPredicate>
    constexpr uint16_t countIf(UnaryPredicate p) {
        uint16_t s = 0;
        for (auto& rec : *this) {
            s += p(rec) ? 1 : 0;
        }
        return s;
    }
 
    constexpr uint16_t count() {
        return countIf([](auto& rec) { rec.isValid(); });
    }
 
    constexpr bool full() { return count() == MaxItemCount; }
};