PartList.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <memory>
#include <type_traits>
#include <algorithm>
#include <mutex>
#include <stdint.h>
 
#include "ship/core/Part.h"
 
namespace Ship {
 
enum class ListReturnCode : int32_t {
    ForcedSuccess = 2,    
    Success = 1,          
    Duplicate = 0,        
    NoItemsProvided = -1, 
    NotPermitted = -2,    
    NotFound = -3,        
    Failed = -4           
};
 
template <typename C, typename StoredPtr> struct PartListStoredPtrTraits;
 
template <typename C> struct PartListStoredPtrTraits<C, std::shared_ptr<C>> {
    static std::shared_ptr<C> Lock(const std::shared_ptr<C>& ptr) {
        return ptr;
    }
 
    static bool IsExpired(const std::shared_ptr<C>& ptr) {
        return ptr == nullptr;
    }
 
    static std::shared_ptr<C> Store(const std::shared_ptr<C>& ptr) {
        return ptr;
    }
};
 
template <typename C> struct PartListStoredPtrTraits<C, std::weak_ptr<C>> {
    static std::shared_ptr<C> Lock(const std::weak_ptr<C>& ptr) {
        return ptr.lock();
    }
 
    static bool IsExpired(const std::weak_ptr<C>& ptr) {
        return ptr.expired();
    }
 
    static std::weak_ptr<C> Store(const std::shared_ptr<C>& ptr) {
        return ptr;
    }
};
 
template <typename C = Part, typename StoredPtr = std::shared_ptr<C>> class PartList : public Part {
  public:
    static_assert(std::is_same<StoredPtr, std::shared_ptr<C>>::value ||
                      std::is_same<StoredPtr, std::weak_ptr<C>>::value,
                  "StoredPtr must be std::shared_ptr<C> or std::weak_ptr<C>");
 
    explicit PartList(const size_t initialAllocation = 0);
    virtual ~PartList() = default;
 
    bool Has(std::shared_ptr<C> part) const;
 
    template <typename T> bool Has() const;
 
    bool Has(const uint64_t id) const;
 
    bool Has() const;
 
    size_t GetCount() const;
 
    uint64_t GetMutationVersion() const {
        return mMutationVersion;
    }
 
    std::shared_ptr<C> Get(const uint64_t id) const;
 
    std::shared_ptr<std::vector<std::shared_ptr<C>>> Get() const;
 
    template <typename T> std::shared_ptr<std::vector<std::shared_ptr<T>>> Get() const;
 
    std::shared_ptr<std::vector<std::shared_ptr<C>>> Get(const std::vector<uint64_t>& ids) const;
 
    template <typename T> std::shared_ptr<T> GetFirst() const;
 
    ListReturnCode Add(std::shared_ptr<C> part, const bool force = false);
 
    ListReturnCode Add(const std::vector<std::shared_ptr<C>>& parts, const bool force = false);
 
    ListReturnCode Remove(std::shared_ptr<C> part, const bool force = false);
 
    ListReturnCode Remove(const uint64_t id, const bool force = false);
 
    ListReturnCode Remove(const bool force = false);
 
    ListReturnCode Remove(const std::vector<std::shared_ptr<C>>& parts, const bool force = false);
 
    template <typename T> ListReturnCode Remove(const bool force = false);
 
    ListReturnCode Remove(const std::vector<uint64_t>& ids, const bool force = false);
 
  protected:
    template <typename P = StoredPtr>
    typename std::enable_if<std::is_same<P, std::shared_ptr<C>>::value, std::vector<P>&>::type GetList();
 
    template <typename P = StoredPtr>
    typename std::enable_if<std::is_same<P, std::shared_ptr<C>>::value, const std::vector<P>&>::type GetList() const;
 
#ifdef COMPONENT_THREAD_SAFE
    std::recursive_mutex& GetMutex() const;
#endif
 
    virtual bool CanAdd(std::shared_ptr<C> part);
 
    virtual bool CanRemove(std::shared_ptr<C> part);
 
    virtual void Added(std::shared_ptr<C> part, const bool forced);
 
    virtual void Removed(std::shared_ptr<C> part, const bool forced);
 
  private:
    using PtrTraits = PartListStoredPtrTraits<C, StoredPtr>;
 
    std::shared_ptr<C> LockPtr(const StoredPtr& ptr) const;
    StoredPtr StorePtr(const std::shared_ptr<C>& ptr) const;
    bool IsExpiredPtr(const StoredPtr& ptr) const;
    void PruneExpired();
    bool ContainsIdUnlocked(const uint64_t id) const;
    bool EraseByIdUnlocked(const uint64_t id, std::shared_ptr<C>* removedPart = nullptr);
 
    std::vector<StoredPtr> mList;
    uint64_t mMutationVersion = 0;
#ifdef COMPONENT_THREAD_SAFE
    mutable std::recursive_mutex mMutex;
#endif
};
 
// ---- Inline implementations ----
 
template <typename C, typename StoredPtr>
PartList<C, StoredPtr>::PartList(const size_t initialAllocation)
    : Part(), mList()
#ifdef COMPONENT_THREAD_SAFE
      ,
      mMutex()
#endif
{
    mList.reserve(initialAllocation);
}
 
template <typename C, typename StoredPtr>
std::shared_ptr<C> PartList<C, StoredPtr>::LockPtr(const StoredPtr& ptr) const {
    return PtrTraits::Lock(ptr);
}
 
template <typename C, typename StoredPtr>
StoredPtr PartList<C, StoredPtr>::StorePtr(const std::shared_ptr<C>& ptr) const {
    return PtrTraits::Store(ptr);
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::IsExpiredPtr(const StoredPtr& ptr) const {
    return PtrTraits::IsExpired(ptr);
}
 
template <typename C, typename StoredPtr> void PartList<C, StoredPtr>::PruneExpired() {
    const auto oldSize = mList.size();
    mList.erase(std::remove_if(mList.begin(), mList.end(), [this](const StoredPtr& ptr) { return IsExpiredPtr(ptr); }),
                mList.end());
    if (mList.size() != oldSize) {
        ++mMutationVersion;
    }
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::ContainsIdUnlocked(const uint64_t id) const {
    return std::find_if(mList.begin(), mList.end(), [this, id](const StoredPtr& item) {
               auto locked = LockPtr(item);
               return locked && locked->GetId() == id;
           }) != mList.end();
}
 
template <typename C, typename StoredPtr>
bool PartList<C, StoredPtr>::EraseByIdUnlocked(const uint64_t id, std::shared_ptr<C>* removedPart) {
    auto it = std::find_if(mList.begin(), mList.end(), [this, id](const StoredPtr& item) {
        auto locked = LockPtr(item);
        return locked && locked->GetId() == id;
    });
 
    if (it == mList.end()) {
        return false;
    }
 
    if (removedPart != nullptr) {
        *removedPart = LockPtr(*it);
    }
 
    mList.erase(it);
    ++mMutationVersion;
    return true;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Add(std::shared_ptr<C> part, const bool force) {
    if (!part) {
        return ListReturnCode::Failed;
    }
 
    const bool canAdd = CanAdd(part);
    if (!canAdd && !force) {
        return ListReturnCode::NotPermitted;
    }
 
    const bool forced = !canAdd && force;
    const uint64_t id = part->GetId();
 
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (ContainsIdUnlocked(id)) {
            return ListReturnCode::Duplicate;
        }
        mList.push_back(StorePtr(part));
        ++mMutationVersion;
    }
 
    bool shouldRunHooks = false;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        shouldRunHooks = ContainsIdUnlocked(id);
    }
 
    if (!shouldRunHooks) {
        return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
    }
 
    try {
        Added(part, forced);
        part->OnAdded(forced);
    } catch (...) {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        EraseByIdUnlocked(id);
        return ListReturnCode::Failed;
    }
 
    return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Add(const std::vector<std::shared_ptr<C>>& parts, const bool force) {
    if (parts.empty()) {
        return ListReturnCode::NoItemsProvided;
    }
 
    ListReturnCode result = ListReturnCode::Duplicate;
    for (const auto& part : parts) {
        const ListReturnCode r = Add(part, force);
        if (static_cast<int32_t>(r) > static_cast<int32_t>(result)) {
            result = r;
        } else if (static_cast<int32_t>(r) < static_cast<int32_t>(ListReturnCode::Duplicate) &&
                   static_cast<int32_t>(r) < static_cast<int32_t>(result)) {
            result = r;
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Remove(std::shared_ptr<C> part, const bool force) {
    if (!part) {
        return ListReturnCode::Failed;
    }
 
    const bool canRemove = CanRemove(part);
    if (!canRemove && !force) {
        return ListReturnCode::NotPermitted;
    }
 
    const bool forced = !canRemove && force;
    const uint64_t id = part->GetId();
    std::shared_ptr<C> removedPart = nullptr;
 
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (!EraseByIdUnlocked(id, &removedPart)) {
            return ListReturnCode::NotFound;
        }
    }
 
    if (!removedPart) {
        return ListReturnCode::NotFound;
    }
 
    bool shouldRunHooks = false;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        shouldRunHooks = !ContainsIdUnlocked(id);
    }
 
    if (!shouldRunHooks) {
        return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
    }
 
    try {
        Removed(removedPart, forced);
        removedPart->OnRemoved(forced);
    } catch (...) {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (!ContainsIdUnlocked(id)) {
            mList.push_back(StorePtr(removedPart));
            ++mMutationVersion;
        }
        return ListReturnCode::Failed;
    }
 
    return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Remove(const uint64_t id, const bool force) {
    std::shared_ptr<C> candidate = nullptr;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (!ContainsIdUnlocked(id)) {
            return ListReturnCode::NotFound;
        }
        auto found = std::find_if(mList.begin(), mList.end(), [this, id](const StoredPtr& item) {
            auto locked = LockPtr(item);
            return locked && locked->GetId() == id;
        });
        candidate = found != mList.end() ? LockPtr(*found) : nullptr;
    }
 
    if (!candidate) {
        return ListReturnCode::NotFound;
    }
 
    const bool canRemove = CanRemove(candidate);
    if (!canRemove && !force) {
        return ListReturnCode::NotPermitted;
    }
 
    const bool forced = !canRemove && force;
    std::shared_ptr<C> removedPart = nullptr;
 
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (!EraseByIdUnlocked(id, &removedPart)) {
            return ListReturnCode::NotFound;
        }
    }
 
    if (!removedPart) {
        return ListReturnCode::NotFound;
    }
 
    bool shouldRunHooks = false;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        shouldRunHooks = !ContainsIdUnlocked(id);
    }
 
    if (!shouldRunHooks) {
        return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
    }
 
    try {
        Removed(removedPart, forced);
        removedPart->OnRemoved(forced);
    } catch (...) {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (!ContainsIdUnlocked(id)) {
            mList.push_back(StorePtr(removedPart));
            ++mMutationVersion;
        }
        return ListReturnCode::Failed;
    }
 
    return forced ? ListReturnCode::ForcedSuccess : ListReturnCode::Success;
}
 
template <typename C, typename StoredPtr> ListReturnCode PartList<C, StoredPtr>::Remove(const bool force) {
    std::vector<std::shared_ptr<C>> snapshot;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
        if (mList.empty()) {
            return ListReturnCode::NotFound;
        }
 
        snapshot.reserve(mList.size());
        for (const auto& item : mList) {
            auto locked = LockPtr(item);
            if (locked) {
                snapshot.push_back(locked);
            }
        }
    }
 
    ListReturnCode result = ListReturnCode::NotFound;
    for (const auto& part : snapshot) {
        const ListReturnCode r = Remove(part, force);
        if (static_cast<int32_t>(r) > static_cast<int32_t>(result)) {
            result = r;
        } else if (static_cast<int32_t>(r) < static_cast<int32_t>(ListReturnCode::Duplicate) &&
                   static_cast<int32_t>(r) < static_cast<int32_t>(result)) {
            result = r;
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Remove(const std::vector<std::shared_ptr<C>>& parts, const bool force) {
    if (parts.empty()) {
        return ListReturnCode::NoItemsProvided;
    }
 
    ListReturnCode result = ListReturnCode::NotFound;
    for (const auto& part : parts) {
        const ListReturnCode r = Remove(part, force);
        if (static_cast<int32_t>(r) > static_cast<int32_t>(result)) {
            result = r;
        } else if (static_cast<int32_t>(r) < static_cast<int32_t>(ListReturnCode::Duplicate) &&
                   static_cast<int32_t>(r) < static_cast<int32_t>(result)) {
            result = r;
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
template <typename T>
ListReturnCode PartList<C, StoredPtr>::Remove(const bool force) {
    std::vector<std::shared_ptr<C>> snapshot;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
 
        snapshot.reserve(mList.size());
        for (const auto& item : mList) {
            auto locked = LockPtr(item);
            if (locked && std::dynamic_pointer_cast<T>(locked) != nullptr) {
                snapshot.push_back(locked);
            }
        }
    }
 
    if (snapshot.empty()) {
        return ListReturnCode::NotFound;
    }
 
    ListReturnCode result = ListReturnCode::NotFound;
    for (const auto& part : snapshot) {
        const ListReturnCode r = Remove(part, force);
        if (static_cast<int32_t>(r) > static_cast<int32_t>(result)) {
            result = r;
        } else if (static_cast<int32_t>(r) < static_cast<int32_t>(ListReturnCode::Duplicate) &&
                   static_cast<int32_t>(r) < static_cast<int32_t>(result)) {
            result = r;
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
ListReturnCode PartList<C, StoredPtr>::Remove(const std::vector<uint64_t>& ids, const bool force) {
    if (ids.empty()) {
        return ListReturnCode::NoItemsProvided;
    }
 
    std::vector<std::shared_ptr<C>> snapshot;
    {
#ifdef COMPONENT_THREAD_SAFE
        const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
        PruneExpired();
 
        snapshot.reserve(mList.size());
        for (const auto& item : mList) {
            auto locked = LockPtr(item);
            if (locked && std::find(ids.begin(), ids.end(), locked->GetId()) != ids.end()) {
                snapshot.push_back(locked);
            }
        }
    }
 
    if (snapshot.empty()) {
        return ListReturnCode::NotFound;
    }
 
    ListReturnCode result = ListReturnCode::NotFound;
    for (const auto& part : snapshot) {
        const ListReturnCode r = Remove(part, force);
        if (static_cast<int32_t>(r) > static_cast<int32_t>(result)) {
            result = r;
        } else if (static_cast<int32_t>(r) < static_cast<int32_t>(ListReturnCode::Duplicate) &&
                   static_cast<int32_t>(r) < static_cast<int32_t>(result)) {
            result = r;
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
template <typename P>
typename std::enable_if<std::is_same<P, std::shared_ptr<C>>::value, std::vector<P>&>::type
PartList<C, StoredPtr>::GetList() {
    return mList;
}
 
template <typename C, typename StoredPtr>
template <typename P>
typename std::enable_if<std::is_same<P, std::shared_ptr<C>>::value, const std::vector<P>&>::type
PartList<C, StoredPtr>::GetList() const {
    return mList;
}
 
#ifdef COMPONENT_THREAD_SAFE
template <typename C, typename StoredPtr> std::recursive_mutex& PartList<C, StoredPtr>::GetMutex() const {
    return mMutex;
}
#endif
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::CanAdd(std::shared_ptr<C> part) {
    return true;
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::CanRemove(std::shared_ptr<C> part) {
    return true;
}
 
template <typename C, typename StoredPtr>
void PartList<C, StoredPtr>::Added(std::shared_ptr<C> part, const bool forced) {
}
 
template <typename C, typename StoredPtr>
void PartList<C, StoredPtr>::Removed(std::shared_ptr<C> part, const bool forced) {
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::Has(std::shared_ptr<C> part) const {
    if (!part) {
        return false;
    }
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    return ContainsIdUnlocked(part->GetId());
}
 
template <typename C, typename StoredPtr> template <typename T> bool PartList<C, StoredPtr>::Has() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    return std::find_if(mList.begin(), mList.end(), [this](const StoredPtr& item) {
               auto locked = LockPtr(item);
               return locked && std::dynamic_pointer_cast<T>(locked) != nullptr;
           }) != mList.end();
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::Has(const uint64_t id) const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    return ContainsIdUnlocked(id);
}
 
template <typename C, typename StoredPtr> bool PartList<C, StoredPtr>::Has() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    return !mList.empty();
}
 
template <typename C, typename StoredPtr> size_t PartList<C, StoredPtr>::GetCount() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    return mList.size();
}
 
template <typename C, typename StoredPtr> std::shared_ptr<C> PartList<C, StoredPtr>::Get(const uint64_t id) const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    auto it = std::find_if(mList.begin(), mList.end(), [this, id](const StoredPtr& item) {
        auto locked = LockPtr(item);
        return locked && locked->GetId() == id;
    });
    return it != mList.end() ? LockPtr(*it) : nullptr;
}
 
template <typename C, typename StoredPtr>
std::shared_ptr<std::vector<std::shared_ptr<C>>> PartList<C, StoredPtr>::Get() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    auto result = std::make_shared<std::vector<std::shared_ptr<C>>>();
    result->reserve(mList.size());
    for (const auto& item : mList) {
        auto locked = LockPtr(item);
        if (locked) {
            result->push_back(locked);
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
template <typename T>
std::shared_ptr<std::vector<std::shared_ptr<T>>> PartList<C, StoredPtr>::Get() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    auto result = std::make_shared<std::vector<std::shared_ptr<T>>>();
    for (const auto& item : mList) {
        auto locked = LockPtr(item);
        if (!locked) {
            continue;
        }
        auto typed = std::dynamic_pointer_cast<T>(locked);
        if (typed) {
            result->push_back(typed);
        }
    }
    return result;
}
 
template <typename C, typename StoredPtr>
template <typename T>
std::shared_ptr<T> PartList<C, StoredPtr>::GetFirst() const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    for (const auto& item : mList) {
        auto locked = LockPtr(item);
        if (!locked) {
            continue;
        }
        auto typed = std::dynamic_pointer_cast<T>(locked);
        if (typed) {
            return typed;
        }
    }
    return nullptr;
}
 
template <typename C, typename StoredPtr>
std::shared_ptr<std::vector<std::shared_ptr<C>>> PartList<C, StoredPtr>::Get(const std::vector<uint64_t>& ids) const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(mMutex);
#endif
    const_cast<PartList<C, StoredPtr>*>(this)->PruneExpired();
    auto result = std::make_shared<std::vector<std::shared_ptr<C>>>();
    for (const auto& item : mList) {
        auto locked = LockPtr(item);
        if (!locked) {
            continue;
        }
        if (std::find(ids.begin(), ids.end(), locked->GetId()) != ids.end()) {
            result->push_back(locked);
        }
    }
    return result;
}
 
} // namespace Ship