ff_simple_edt.h

//
//  ff_simple_edt.h
//  RGPLua
//
//  Created by Robert Patterson on 3/3/24.
//
 
#ifndef ff_simple_edt_h
#define ff_simple_edt_h
 
#include <optional>
#include <finalepdk.h>
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
const size_t kInciSize = 12;
 
template <typename EDTTYPE, EXTAG TAG>
class __FCSimpleEDTStruct : public EDTTYPE
{
protected:
    EDataID _id;
    
    __FCSimpleEDTStruct() // can only be constructed by subclasses
    { memset(this, 0, sizeof(*this)); }
    
    __FCSimpleEDTStruct(const EDTTYPE& edtStruct) : EDTTYPE(edtStruct) // can only be constructed by subclasses
    { memset(&_id, 0, sizeof(_id)); }
    
public:
    void InitializeEDTStruct()
    {
        EDTTYPE * pEDT = dynamic_cast<EDTTYPE * >(this);
        assert(pEDT != nullptr);
        memset(pEDT, 0, sizeof(EDTTYPE));
    }
    
    bool Load(std::optional<std::reference_wrapper<EDTTYPE>> copyToStruct = std::nullopt)
    {
        fourbyte datasize = sizeof(EDTTYPE);
        bool retval = FX_LoadEData(TAG, &_id, static_cast<EDTTYPE *>(this), &datasize);
        if (retval && copyToStruct.has_value())
            copyToStruct.value().get() = *static_cast<EDTTYPE *>(this);
        return retval;
    }
    
    bool LoadFirst()
    {
        if (Load()) return true;
        return LoadNext();
    }
    
    bool LoadNext() { return FX_NextEData(TAG, &_id, static_cast<EDTTYPE *>(this), sizeof(EDTTYPE)); }
    bool LoadPrevious() { return FX_PreviousEData(TAG, &_id, static_cast<EDTTYPE *>(this), sizeof(EDTTYPE)); }
    bool Save() { return FX_SaveEData(TAG, &_id, static_cast<EDTTYPE *>(this), sizeof(EDTTYPE)); }
    bool Create() { return FX_CreateEData(TAG, &_id, static_cast<EDTTYPE *>(this), sizeof(EDTTYPE)); }
    bool Delete() { return FX_DeleteEData(TAG, &_id); }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCSimpleOther : public __FCSimpleEDTStruct<EDTTYPE,TAG>
{
public:
    __FCSimpleOther(const CMPER cmper = kNewCmper, const twobyte inci = 0)
    {
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.cmper = cmper;
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.inci = inci;
    }
    
    __FCSimpleOther(const EDTTYPE& edtStruct, const CMPER cmper = kNewCmper, const twobyte inci = 0) : __FCSimpleEDTStruct<EDTTYPE,TAG>(edtStruct)
    {
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.cmper = cmper;
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.inci = inci;
    }
    
    CMPER GetCmper() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.cmper; }
    
    void SetCmper(const CMPER cmper)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.cmper = cmper; }
    
    twobyte GetInci() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.inci; }
    
    void SetInci(const twobyte inci)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.other.inci = inci; }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCSimpleDetail : public __FCSimpleEDTStruct<EDTTYPE,TAG>
{
public:
    __FCSimpleDetail(const CMPER cmper1 = kNewCmper, const CMPER cmper2 = kNewCmper2, const twobyte inci = 0)
    {
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.cmper1 = cmper1;
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.cmper2 = cmper2;
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.inci = inci;
    }
    
    __FCSimpleDetail(const EDTTYPE& edtStruct, const CMPER cmper1 = kNewCmper, const CMPER cmper2 = kNewCmper2, const twobyte inci = 0) :
    __FCSimpleEDTStruct<EDTTYPE,TAG>(edtStruct)
    {
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.cmper1 = cmper1;
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.cmper2 = cmper2;
        __FCSimpleDetail<EDTTYPE,TAG>::_id.detail.inci = inci;
    }
    
    CMPER GetCmper1() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.cmper1; }
    
    void SetCmper1(const CMPER cmper)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.cmper1 = cmper; }
    
    CMPER GetCmper2() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.cmper2; }
    
    void SetCmper2(const CMPER cmper)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.cmper2 = cmper; }
    
    twobyte GetInci() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.inci; }
    
    void SetInci(const twobyte inci)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.detail.inci = inci; }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCSimpleEntryDetail : public __FCSimpleEDTStruct<EDTTYPE,TAG>
{
public:
    __FCSimpleEntryDetail(const ENTNUM entryNumber = kNewEntryNum, const twobyte inci = 0)
    {
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.entryNumber = entryNumber;
        __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.inci = inci;
    }
    
    ENTNUM GetEntryNumber() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.entryNumber; }
    
    void SetEntryNumber(const ENTNUM entryNumber)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.entryNumber = entryNumber; }
    
    twobyte GetInci() const
    { return __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.inci; }
    
    void SetInci(const twobyte inci)
    { __FCSimpleEDTStruct<EDTTYPE,TAG>::_id.entryDetail.inci = inci; }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCEnigmaArray
{
    static_assert(HI_UTWOBYTE(TAG) == edOther || HI_UTWOBYTE(TAG) == edDetail, "EXTAG must be edDetail or edOther");
    static constexpr bool IS_DETAIL = HI_UTWOBYTE(TAG) == edDetail;
    
    CMPER _cmper1;
    CMPER _cmper2;
    
    int _maxelements; // the caller can specify a number of elements smaller than the full last inci
    std::vector<char> _buffer;
    
    static constexpr size_t INCISIZE = std::conditional_t<IS_DETAIL, std::integral_constant<size_t, 5>, std::integral_constant<size_t, 6>>::value;
    class INCITYPE
    {
        twobyte inci[INCISIZE];
    };
    
    void AddToBuffer(const INCITYPE& inci)
    {
        size_t currsize = _buffer.size();
        _buffer.resize(currsize + sizeof(inci));
        memcpy(&_buffer[currsize], &inci, sizeof(inci));
    }
    
    auto GetInciType()
    {
        if constexpr(IS_DETAIL)
            return __FCSimpleDetail<INCITYPE, TAG>(_cmper1, _cmper2, 0);
        else
            return __FCSimpleOther<INCITYPE, TAG>(_cmper1, 0);
    }
    
    bool GetInci(size_t incino, INCITYPE& inci)
    {
        size_t buffx = incino * sizeof(inci);
        if (buffx < _buffer.size())
        {
            memset(&inci, 0, sizeof(inci));
            memcpy(&inci, &_buffer[buffx], (std::min)(sizeof(inci), _buffer.size() - buffx));
            return true;
        }
        return false;
    }
    
    template <class T>
    void StoreCmpers(const T& inci)
    {
        if constexpr(IS_DETAIL)
        {
            _cmper1 = inci.GetCmper1();
            _cmper2 = inci.GetCmper2();
        }
        else
        {
            _cmper1 = inci.GetCmper();
            _cmper2 = 0;
        }
    }
    
protected:
    void AssignBuffer(const void* buffer, size_t numbytes)
    {
        _buffer.clear();
        _buffer.resize(numbytes);
        memcpy(_buffer.data(), buffer, _buffer.size());
    }
    
    bool _Load(CMPER cmper1, CMPER cmper2)
    {
        _cmper1 = cmper1;
        _cmper2 = cmper2;
        auto loader = GetInciType();
        _buffer.clear();
        for (EINCI inci = 0; true; inci++)
        {
            loader.SetInci(inci);
            if (!loader.Load()) break;
            AddToBuffer(loader);
        }
        return _buffer.size() > 0;
    }
    
    bool _SaveAs(CMPER cmper1, CMPER cmper2)
    {
        _cmper1 = cmper1;
        _cmper2 = cmper2;
        return Save();
    }
        
    bool _Delete(CMPER cmper1, CMPER cmper2)
    {
        _cmper1 = cmper1;
        _cmper2 = cmper2;
        return Delete();
    }
    
    CMPER _GetCmper1() const { return _cmper1; }
    CMPER _GetCmper2() const { return _cmper2; }
    
    void _SetCmper1(CMPER cmper) { _cmper1 = cmper; }
    void _SetCmper2(CMPER cmper) { _cmper2 = cmper; }
 
    const void* GetBuffer() const { return _buffer.data(); }
 
    __FCEnigmaArray(const int maxelements) : _cmper1(kNewCmper), _cmper2(0), _maxelements(maxelements)
    {
        if (maxelements) AllocateFor(maxelements);
    }
    
public:
    
    EDTTYPE& operator[](const size_t x)
    {
        const size_t requiredSize = (x + 1) * sizeof(EDTTYPE);
        if (requiredSize > _buffer.size())
            _buffer.resize(requiredSize);
        return reinterpret_cast<EDTTYPE *>(_buffer.data())[x];
    }
    
    const EDTTYPE& operator[](const size_t x) const
    {
        assert(x * sizeof(EDTTYPE) <= _buffer.size() - sizeof(EDTTYPE));
        return reinterpret_cast<const EDTTYPE *>(_buffer.data())[x];
    }
    
    void Reset()
    {
        _buffer.clear();
    }
 
    int NumElements() const
    {
        assert(_buffer.size() % sizeof(EDTTYPE) == 0);
        int _physicalElements = static_cast<int>(_buffer.size() / sizeof(EDTTYPE));
        if (_maxelements)
            return (std::min)(_physicalElements, _maxelements);
        return _physicalElements;
    }
    
    void AllocateFor(const int numelements)
    {
        assert(numelements >= 0);
        _buffer.clear();
        if (numelements)
        {
            size_t newsize = numelements * sizeof(EDTTYPE);
            size_t remainder = newsize % INCISIZE*sizeof(twobyte);
            if (remainder) newsize += remainder;
            _buffer.resize(newsize);
        }
        _maxelements = numelements;
    }
    
    bool LoadNext()
    {
        auto inci = GetInciType();
        inci.SetInci(TWOBYTE_MAX);
        if (inci.LoadNext())
        {
            StoreCmpers(inci);
            return _Load(_cmper1, _cmper2);
        }
        return false;
    }
    
    bool LoadFirst()
    {
        if (_Load(0,0)) return true;
        return LoadNext();
    }
    
    bool Save()
    {
        Delete();
        auto saver = GetInciType();
        for (int inci = 0; GetInci(inci, saver); inci++)
        {
            saver.SetInci(inci);
            bool success = (_cmper1 == kNewCmper) ? saver.Create() : saver.Save();
            if (!success) return false;
        }
        StoreCmpers(saver);
        return true;
    }
    
    bool Delete()
    {
        auto deleter = GetInciType();
        bool deletedSomething = false;
        while (deleter.Delete())
            deletedSomething = true;
        return deletedSomething;
    }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCEnigmaOtherArray : public __FCEnigmaArray<EDTTYPE, TAG>
{
    static_assert(HI_UTWOBYTE(TAG) == edOther, "EXTAG must be edOther");
    using __FCEnigmaOtherArrayBase = __FCEnigmaArray<EDTTYPE, TAG>;
    
public:
    __FCEnigmaOtherArray(const int maxelements = 0) : __FCEnigmaOtherArrayBase(maxelements) {}
    
    CMPER GetCmper() const { return this->_GetCmper1(); }
    void SetCmper(CMPER cmper) { this->_SetCmper1(cmper); }
    
    bool Load(CMPER cmper) { return this->_Load(cmper, 0); }
    bool SaveAs(CMPER cmper) { return this->_SaveAs(cmper, 0); }
    bool Delete(CMPER cmper) { return this->_Delete(cmper, 0); }
};
 
template <typename EDTTYPE, EXTAG TAG>
class __FCEnigmaDetailArray : public __FCEnigmaArray<EDTTYPE, TAG>
{
    static_assert(HI_UTWOBYTE(TAG) == edDetail, "EXTAG must be edDetail");
    using __FCEnigmaDetailArrayBase = __FCEnigmaArray<EDTTYPE, TAG>;
    
public:
    __FCEnigmaDetailArray(const int maxelements = 0) : __FCEnigmaDetailArrayBase(maxelements) {}
    
    using __FCEnigmaDetailArrayBase::LoadFirst;
    
    CMPER GetCmper1() const { return this->_GetCmper1(); }
    CMPER GetCmper2() const { return this->_GetCmper2(); }
    
    void SetCmper1(CMPER cmper) { this->_SetCmper1(cmper); }
    void SetCmper2(CMPER cmper) { this->_SetCmper2(cmper); }
 
    bool Load(CMPER cmper1, CMPER cmper2) { return this->_Load(cmper1, cmper2); }
    bool SaveAs(CMPER cmper1, CMPER cmper2) { return this->_SaveAs(cmper1, cmper2); }
    bool Delete(CMPER cmper1, CMPER cmper2) { return this->_Delete(cmper1, cmper2); }
    
    bool LoadNext(CMPER cmper1)
    {
        if (!__FCEnigmaDetailArrayBase::LoadNext()) return false;
        return (cmper1 == GetCmper1());
    }
    
    bool LoadFirst(CMPER cmper1)
    {
        if (Load(cmper1, 0)) return true;
        return LoadNext(cmper1);
    }
    
    bool LoadNextCmper1()
    {
        if (GetCmper1() == kNewCmper) return false; // kNewCmper is also the max cmper value
        if (Load(GetCmper1() + 1, 0)) return true;
        return __FCEnigmaDetailArrayBase::LoadNext();
    }
    
    bool Delete(CMPER cmper1)
    {
        if (LoadFirst(cmper1))
        {
            Delete(cmper1, GetCmper2());
            while (LoadNext(cmper1))
                Delete(cmper1, GetCmper2());
            return true;
        }
        return false;
    }
};
 
template <typename CHARTYPE, EXTAG TAG>
class __FCEnigmaArrayString : public std::conditional_t<HI_UTWOBYTE(TAG) == edDetail, __FCEnigmaDetailArray<CHARTYPE, TAG>, __FCEnigmaOtherArray<CHARTYPE, TAG>>
{
    static_assert(std::is_integral<CHARTYPE>::value, "CHARTYPE must be an integer type");
    using __FCEnigmaArrayStringBase = std::conditional_t<HI_UTWOBYTE(TAG) == edDetail, __FCEnigmaDetailArray<CHARTYPE, TAG>, __FCEnigmaOtherArray<CHARTYPE, TAG>>;
    
public:
    __FCEnigmaArrayString() : __FCEnigmaArrayStringBase() {}
    
    template<std::size_t N>
    __FCEnigmaArrayString(const CHARTYPE (&inpstr)[N]) : __FCEnigmaArrayStringBase()
    { AssignString<N>(inpstr); }
    
    template<std::size_t N>
    void AssignString(const CHARTYPE (&inpstr)[N])
    {
        const std::size_t bufLen = sizeof(CHARTYPE) * (std::min)(N, std::char_traits<CHARTYPE>::length(inpstr) + 1);
        __FCEnigmaArrayStringBase::AssignBuffer(inpstr, bufLen);
    }
    
    void AssignString(const CHARTYPE* inpstr)
    {
        const std::size_t bufLen = sizeof(CHARTYPE) * std::char_traits<CHARTYPE>::length(inpstr) + 1;
        __FCEnigmaArrayStringBase::AssignBuffer(inpstr, bufLen);
    }
    
    const CHARTYPE* GetString() const { return reinterpret_cast<const CHARTYPE*>(this->GetBuffer()); }
};
 
template<size_t SIZE>
struct __FCEnigmaInciStruct
{
    twobyte data[SIZE];
    const twobyte& operator[](size_t index) const { return data[index]; }
    twobyte& operator[](size_t index) { return data[index]; }
};
template<EXTAG TAG>
class __FCEnigmaOtherInci : public __FCSimpleOther<__FCEnigmaInciStruct<6>, TAG>
{
public:
    __FCEnigmaOtherInci(CMPER cmper, twobyte inci) : __FCSimpleOther<__FCEnigmaInciStruct<6>, TAG>(cmper, inci) {}
};
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
 
#endif /* ff_simple_edt_h */