Libraries.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "HardwareAdapter.h"
#include "Instrument.h"
#include "Module.h"
 
namespace DynExp
{
    template <typename ObjectTypeBasePtr>
    using LibraryObjectFactoryPtrType = ObjectTypeBasePtr(*)(const std::thread::id, ParamsBasePtrType&&);
 
    using LibraryConfigFactoryPtrType = ConfiguratorBasePtrType(*)();
 
    using LibraryStringType = const char*;
 
    using LibraryStringParamPtrType = LibraryStringType(*)();
 
    template <typename ObjectTypeBasePtr, LibraryObjectFactoryPtrType<ObjectTypeBasePtr>...>
    class LibraryObjectFactoryParamList {};
 
    template <LibraryConfigFactoryPtrType...>
    class LibraryConfigFactoryParamList {};
 
    template <LibraryStringParamPtrType...>
    class LibraryStringParamList {};
 
    template <typename ObjectTypeBasePtr>
    struct LibraryEntry
    {
        constexpr LibraryEntry(const LibraryObjectFactoryPtrType<ObjectTypeBasePtr> ObjectFactoryPtr,
            const LibraryConfigFactoryPtrType ConfigFactoryPtr,
            const LibraryStringType Name, const LibraryStringType Category) noexcept
            : ObjectFactoryPtr(ObjectFactoryPtr), ConfigFactoryPtr(ConfigFactoryPtr),
            Name(Name), Category(Category)
        {}
 
        LibraryObjectFactoryPtrType<ObjectTypeBasePtr> ObjectFactoryPtr;    
        LibraryConfigFactoryPtrType ConfigFactoryPtr;                       
        LibraryStringType Name;                                             
        LibraryStringType Category;                                         
    };
 
    template <typename ObjectTypeBasePtr,
        typename ObjFactories,
        typename ConfFactories,
        typename ObjNames,
        typename ObjCategories
    >
    class LibraryBase;
 
    template <typename ObjectTypeBasePtr,
        LibraryObjectFactoryPtrType<ObjectTypeBasePtr>... ObjFactories,
        LibraryConfigFactoryPtrType... ConfFactories,
        LibraryStringParamPtrType... NameFuncs,
        LibraryStringParamPtrType... CategoryFuncs
    >
    class LibraryBase<
        ObjectTypeBasePtr,
        LibraryObjectFactoryParamList<ObjectTypeBasePtr, ObjFactories...>,
        LibraryConfigFactoryParamList<ConfFactories...>,
        LibraryStringParamList<NameFuncs...>,
        LibraryStringParamList<CategoryFuncs...>
    >
    {
    protected:
        constexpr LibraryBase() : Entries{ LibraryEntry(ObjFactories, ConfFactories, NameFuncs(), CategoryFuncs())... }
        {
            std::sort(Entries.begin(), Entries.end(), [](const auto& a, const auto& b) constexpr {
                using ct = std::char_traits<char>;
 
                // Sort by category first...
                const auto CategoryDiff = ct::compare(a.Category, b.Category,
                    std::min(ct::length(a.Category), ct::length(b.Category)));
 
                // ...and by name second if categories equal.
                if (CategoryDiff == 0)
                    return std::lexicographical_compare(a.Name, a.Name + ct::length(a.Name),
                        b.Name, b.Name + ct::length(b.Name));
 
                return CategoryDiff < 0;
            }); 
        }
 
        ~LibraryBase() = default;
 
    public:
        constexpr const auto& GetLibrary() const noexcept { return Entries; }
 
        auto ToVector() const
        {
            return std::vector<LibraryEntry<ObjectTypeBasePtr>>(Entries.cbegin(), Entries.cend());
        }
 
    private:
        std::array<LibraryEntry<ObjectTypeBasePtr>, sizeof...(ObjFactories)> Entries;
    };
 
    template <typename... HardwareAdapterTypes>
    class HardwareAdapterLibrary : public LibraryBase<
        HardwareAdapterPtrType,
        LibraryObjectFactoryParamList<HardwareAdapterPtrType, &MakeHardwareAdapter<HardwareAdapterTypes>...>,
        LibraryConfigFactoryParamList<&MakeHardwareAdapterConfig<HardwareAdapterTypes>...>,
        LibraryStringParamList<&HardwareAdapterTypes::Name...>,
        LibraryStringParamList<&HardwareAdapterTypes::Category...>
    >
    {};
 
    using HardwareAdapterLibraryVectorType = std::vector<LibraryEntry<HardwareAdapterPtrType>>;
 
    template <typename... InstrumentTypes>
    class InstrumentLibrary : public LibraryBase<
        InstrumentPtrType,
        LibraryObjectFactoryParamList<InstrumentPtrType, &MakeInstrument<InstrumentTypes>...>,
        LibraryConfigFactoryParamList<&MakeInstrumentConfig<InstrumentTypes>...>,
        LibraryStringParamList<&InstrumentTypes::Name...>,
        LibraryStringParamList<&InstrumentTypes::Category...>
    >
    {};
 
    using InstrumentLibraryVectorType = std::vector<LibraryEntry<InstrumentPtrType>>;
 
    template <typename... ModuleTypes>
    class ModuleLibrary : public LibraryBase<
        ModulePtrType,
        LibraryObjectFactoryParamList<ModulePtrType, &MakeModule<ModuleTypes>...>,
        LibraryConfigFactoryParamList<&MakeModuleConfig<ModuleTypes>...>,
        LibraryStringParamList<&ModuleTypes::Name...>,
        LibraryStringParamList<&ModuleTypes::Category...>
    >
    {};
 
    using ModuleLibraryVectorType = std::vector<LibraryEntry<ModulePtrType>>;
 
    template <typename LibraryVectorT>
    const typename LibraryVectorT::value_type& FindInLibraryVector(const LibraryVectorT& LibraryVector,
        const std::string& Category, const std::string& Name)
    {
        auto Result = std::find_if(LibraryVector.cbegin(), LibraryVector.cend(),
            [&Category, &Name](const auto& LibEntry) {
                return Category == std::string(LibEntry.Category) && Name == std::string(LibEntry.Name);
        });
 
        if (Result == LibraryVector.cend())
            throw Util::NotFoundException("An item (" + Object::CategoryAndNameToStr(Category, Name)
                + ") has not been found in the given library vector.");
 
        return *Result;
    }
}