Field.cpp

/* File: Field.cpp
   Project: Kanabo
   Purpose: Stores an individual field of data found in a resource. Each subclass of FieldT has a unique combination of underlying data type and
            representation of that data, e.g. FieldOffset is the same size as FieldU32 but represented differently to the user (see the str()
            methods). Some data types used for these classes are built-in types and some are defined in DataIO. Functions in DataIO are used
            for any complex data-printing needs.
   Notes: Used by GameData to collect fields into Templates and also to compose the header of the game data file.
   Margin Guide: |----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----|
   Copyright 2026 Iritscen */

#include "Field.hpp"

#include <cmath>     // for std::abs
#include <cstdlib>   // for strtod, strtoull
#include <format> // needed on Windows for std::format
#include <iomanip>   // for std::quoted
#include <iostream> // for cout, cerr
#include <set>       // for std::set

using std::abs;
using std::array;
using std::cerr;
using std::format;
using std::function;
using std::map;
using std::quoted;
using std::set;
using std::span;
using std::string;
using std::vector;

// A safeguard to make sure we don't allocate insane amounts of memory if a raw size is misread; the largest observed instance in the data is an
// AGQG of 2.4 MB which, if AGQG is not implemented, will be handled by TemplateCatchAll which will load its data into a FieldDataBlob
const int kBlobSizeSafety = 10 * 1000 * 1000;
const int kPaddingSizeSafety = 1000;

/******************************* Field *******************************/
Field::Field(string hrName, int order, bool display, bool save)
     : name_(std::move(hrName)),
       orders_{order, order, order, order, order},
       offsets_{kOffsetAbsent, kOffsetAbsent, kOffsetAbsent, kOffsetAbsent, kOffsetAbsent},
       show_(display),
       save_(save),
       origFormat_(Format::Unknown),
       curFormat_(Format::PC1_0)
{

}

Field::Field(string hrName, array<int, 5> orders, bool display, bool save)
     : name_(std::move(hrName)),
       orders_(orders),
       offsets_{kOffsetAbsent, kOffsetAbsent, kOffsetAbsent, kOffsetAbsent, kOffsetAbsent},
       show_(display),
       save_(save),
       origFormat_(Format::Unknown),
       curFormat_(Format::PC1_0)
{

}

string & Field::name()
{
    return name_;
}

uint32_t & Field::offset()
{
    return offsets_[static_cast<size_t>(curFormat_)];
}

uint32_t Field::offsetFor(Format fmt) const
{
    int idx = static_cast<int>(fmt);
    if (idx < 0 || idx >= 5)
        return kOffsetAbsent;
    return offsets_[static_cast<size_t>(idx)];
}

int Field::orderFor(Format fmt) const
{
    int idx = static_cast<int>(fmt);
    if (idx < 0 || idx >= 5)
        return kOrderAbsent;
    return orders_[static_cast<size_t>(idx)];
}

Format Field::originalFormat()
{
    return origFormat_;
}

void Field::setCurrentFormat(Format fmt)
{
    // If "origFormat_" is not set, this is our first run and we're being called from Template::processData(). This is slightly hacky but it's a
    // way to record the field's original format so that if we're exporting or otherwise converting the data to another format later we know
    // what format we're coming from. The "proper" way would be to change every template to pass its data format to every field in its
    // initializer list, which is a vastly more verbose way to achieve the same result.
    if (origFormat_ == Format::Unknown)
        origFormat_ = fmt;
    curFormat_ = fmt;
}

void Field::setOffset(uint32_t offset)
{
    offsets_.fill(offset);
}

bool & Field::show()
{
    return show_;
}

bool & Field::save()
{
    return save_;
}

// Classify the semantic category of "filterVal" based on its syntax
FilterValueKind Field::classifyFilterValue(const string & filterVal)
{
    if (filterVal.empty())
        return FilterValueKind::Textual;

    // "!=" negation prefix is only meaningful before a numeric value; classify the remainder and promote to Numeric or ignore
    if (filterVal.size() > 2 && filterVal[0] == '!' && filterVal[1] == '=')
    {
        if (classifyFilterValue(filterVal.substr(2)) == FilterValueKind::Numeric)
            return FilterValueKind::Numeric;
    }

    // Check for flag filter syntax
    if (filterVal == "has none")
        return FilterValueKind::Flag;
    if (filterVal.size() > 4 && filterVal.substr(0, 4) == "has:")
        return FilterValueKind::Flag;
    if (filterVal.size() > 7 && filterVal.substr(0, 7) == "has no:")
        return FilterValueKind::Flag;

    // Check for type code syntax
    if (filterVal.size() > 5 && filterVal.substr(0, 5) == "type:")
        return FilterValueKind::TypeCode;
    if (filterVal.size() > 9 && filterVal.substr(0, 9) == "type not:")
        return FilterValueKind::TypeCode;

    // Check for boolean keywords
    if (filterVal == "true" || filterVal == "false" || filterVal == "yes" || filterVal == "no")
        return FilterValueKind::Boolean;

    // Check for a comparison operator prefix: <=, >=, <, >
    if (filterVal[0] == '<' || filterVal[0] == '>')
    {
        size_t numStart = (filterVal.size() >= 2 && filterVal[1] == '=') ? 2 : 1;
        double dummy;
        if (tryParseDouble(filterVal.substr(numStart), dummy))
            return FilterValueKind::Numeric;
    }

    // Check for a numeric range: find the first '-' that is not a leading sign character
    size_t hyphenPos = filterVal.find('-', 1);
    if (hyphenPos != string::npos)
    {
        double startVal, endVal;
        if (tryParseDouble(filterVal.substr(0, hyphenPos), startVal) && tryParseDouble(filterVal.substr(hyphenPos + 1), endVal))
            return FilterValueKind::Numeric;
    }

    // Check for a plain numeric value, with optional leading '=' (e.g. "=256" treated the same as "256")
    double dummy;
    string stripped = (filterVal[0] == '=') ? filterVal.substr(1) : filterVal;
    if (tryParseDouble(stripped, dummy))
        return FilterValueKind::Numeric;

    return FilterValueKind::Textual;
}

// Parse "s" as a numeric double; strips commas and handles hex (0x/0X prefix). Returns false if "s" is not a valid number.
bool Field::tryParseDouble(const string & s, double & result)
{
    if (s.empty())
        return false;

    // Strip commas (locale-formatted numbers such as "1,010" produced by the {:L} format specifier)
    string stripped;
    stripped.reserve(s.size());
    for (char c : s)
    {
        if (c != ',')
            stripped += c;
    }

    // Handle hex prefix "0x..." or "0X..."
    if (stripped.size() >= 3 && stripped[0] == '0' && (stripped[1] == 'x' || stripped[1] == 'X'))
    {
        char * endPtr;
        uint64_t hexVal = strtoull(stripped.c_str(), &endPtr, 16);
        if (endPtr != stripped.c_str() && *endPtr == '\0')
        {
            result = static_cast<double>(hexVal);
            return true;
        }
        return false;
    }

    char * endPtr;
    result = strtod(stripped.c_str(), &endPtr);
    return (endPtr != stripped.c_str() && *endPtr == '\0');
}

// Compare "fieldStr" against "filterVal" numerically. Supports comparison operators (>=, <=, >, <), inclusive ranges (e.g. "5-20"), and
// exact value with floating-point tolerance.
bool Field::numericMatch(const string & fieldStr, const string & filterVal)
{
    constexpr double kTolerance = 1e-4;

    // Handle "!=" negation prefix
    if (filterVal.size() > 2 && filterVal[0] == '!' && filterVal[1] == '=')
        return !numericMatch(fieldStr, filterVal.substr(2));

    // Strip a leading '=' (equality prefix) so "=256" is treated the same as "256"
    string const & fv = (not filterVal.empty() && filterVal[0] == '=') ? filterVal.substr(1) : filterVal;

    // Check for a comparison operator prefix: <=, >=, <, >
    if (fv.size() >= 2 && (fv[0] == '<' || fv[0] == '>'))
    {
        bool isLessOrEqual    = (fv.substr(0, 2) == "<=");
        bool isGreaterOrEqual = (fv.substr(0, 2) == ">=");
        bool isLess    = (!isLessOrEqual    && fv[0] == '<');
        bool isGreater = (!isGreaterOrEqual && fv[0] == '>');
        size_t numStart = (isLessOrEqual || isGreaterOrEqual) ? 2 : 1;
        string numStr = fv.substr(numStart);
        double filterDouble, fieldDouble;
        if (tryParseDouble(numStr, filterDouble) && tryParseDouble(fieldStr, fieldDouble))
        {
            if (isLessOrEqual)    return (fieldDouble <= filterDouble);
            if (isGreaterOrEqual) return (fieldDouble >= filterDouble);
            if (isLess)           return (fieldDouble <  filterDouble);
            if (isGreater)        return (fieldDouble >  filterDouble);
        }
        return false; // operator present but operand is not numeric; cannot match
    }

    // Check for a range: find the first '-' that is not the leading sign character
    size_t hyphenPos = fv.find('-', 1);
    if (hyphenPos != string::npos)
    {
        string startStr = fv.substr(0, hyphenPos);
        string endStr   = fv.substr(hyphenPos + 1);
        double startVal, endVal, fieldDouble;
        if (tryParseDouble(startStr, startVal) && tryParseDouble(endStr, endVal) && tryParseDouble(fieldStr, fieldDouble))
        {
            if (endVal < startVal)
                return false;
            return (fieldDouble >= startVal - kTolerance && fieldDouble <= endVal + kTolerance);
        }
    }

    // Single numeric comparison with tolerance
    double filterDouble, fieldDouble;
    if (tryParseDouble(fv, filterDouble) && tryParseDouble(fieldStr, fieldDouble))
        return (abs(fieldDouble - filterDouble) < kTolerance);

    return false;
}

// Default implementation for value-filter matching. Handles numeric (Numeric, Offset, Checksum kinds) and textual (Textual, Tag kinds) filter
// types. Subclasses with richer semantics (Boolean, FlagSet, TypeCode, Link, Date, Size) override this method.
bool Field::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    FieldKind fk = kind();

    if (fk == FieldKind::Binary)
        return false; // no meaningful way to filter against binary data

    if (fvk == FilterValueKind::Numeric)
    {
        // Numeric, Offset, and Checksum fields have str()s that return a plain number or hex value; both are handled by numericMatch()
        if (fk == FieldKind::Numeric || fk == FieldKind::Offset || fk == FieldKind::Checksum)
            return numericMatch(str(), filterVal);
        return false;
    }

    if (fvk == FilterValueKind::Textual)
    {
        if (fk == FieldKind::Textual)
            return str() == filterVal;
        if (fk == FieldKind::Tag)
            return str() == filterVal;
        return false;
    }

    return false; // Boolean, Flag, and TypeCode filters are handled exclusively by subclass overrides
}

/****************************** FieldT *******************************/
template<typename T>
FieldT<T>::FieldT(string hrName, int order, bool display, bool save, T value, T valueDefault)
         : Field(std::move(hrName), order, display, save),
           value_(value), // NOLINT(performance-unnecessary-value-param)
           valueDefault_(valueDefault) // NOLINT(performance-unnecessary-value-param)
{

}

template<typename T>
FieldT<T>::FieldT(string hrName, array<int, 5> orders, bool display, bool save, T value, T valueDefault)
         : Field(std::move(hrName), orders, display, save),
           value_(value), // NOLINT(performance-unnecessary-value-param)
           valueDefault_(valueDefault) // NOLINT(performance-unnecessary-value-param)
{

}

template<typename T>
uint32_t FieldT<T>::size()
{
    return static_cast<uint32_t>(sizeof(T));
}

/****************************** FieldU8 ******************************/
FieldU8::FieldU8(string hrName, int order, bool display, bool save, uint8_t value, uint8_t valueDefault)
       : FieldT<uint8_t>(std::move(hrName), order, display, save),
         valueU8_(value),
         defaultValueU8_(valueDefault)
{

}

FieldU8::FieldU8(string hrName, array<int, 5> orders, bool display, bool save, uint8_t value, uint8_t valueDefault)
        : FieldT<uint8_t>(std::move(hrName), orders, display, save),
          valueU8_(value),
          defaultValueU8_(valueDefault)
{

}

ValueVariant & FieldU8::var()
{
    return valueU8_;
}

ValueVariant & FieldU8::defVar()
{
    return defaultValueU8_;
}

uint8_t & FieldU8::val()
{
    return get<uint8_t>(valueU8_);
}

uint8_t & FieldU8::defVal()
{
    return get<uint8_t>(defaultValueU8_);
}

const string FieldU8::str()
{
    string s = format("{}", val());
    return s;
}

FieldKind FieldU8::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldS16 ******************************/
FieldS16::FieldS16(string hrName, int order, bool display, bool save, int16_t value, int16_t valueDefault)
        : FieldT<int16_t>(std::move(hrName), order, display, save),
          valueS16_(value),
          defaultValueS16_(valueDefault)
{

}

FieldS16::FieldS16(string hrName, array<int, 5> orders, bool display, bool save, int16_t value, int16_t valueDefault)
        : FieldT<int16_t>(std::move(hrName), orders, display, save),
          valueS16_(value),
          defaultValueS16_(valueDefault)
{

}

ValueVariant & FieldS16::var()
{
    return valueS16_;
}

ValueVariant & FieldS16::defVar()
{
    return defaultValueS16_;
}

int16_t & FieldS16::val()
{
    return get<int16_t>(valueS16_);
}

int16_t & FieldS16::defVal()
{
    return get<int16_t>(defaultValueS16_);
}

const string FieldS16::str()
{
    string s = format("{:L}", val()); // uses the custom locale we created and set globally in main()
    return s;
}

FieldKind FieldS16::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldU16 ******************************/
FieldU16::FieldU16(string hrName, int order, bool display, bool save, uint16_t value, uint16_t valueDefault)
        : FieldT<uint16_t>(std::move(hrName), order, display, save),
          valueU16_(value),
          defaultValueU16_(valueDefault)
{

}

FieldU16::FieldU16(string hrName, array<int, 5> orders, bool display, bool save, uint16_t value, uint16_t valueDefault)
        : FieldT<uint16_t>(std::move(hrName), orders, display, save),
          valueU16_(value),
          defaultValueU16_(valueDefault)
{

}

ValueVariant & FieldU16::var()
{
    return valueU16_;
}

ValueVariant & FieldU16::defVar()
{
    return defaultValueU16_;
}

uint16_t & FieldU16::val()
{
    return get<uint16_t>(valueU16_);
}

uint16_t & FieldU16::defVal()
{
    return get<uint16_t>(defaultValueU16_);
}

const string FieldU16::str()
{
    string s = format("{:L}", val()); // uses the custom locale we created and set globally in main()
    return s;
}

FieldKind FieldU16::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldS32 ******************************/
FieldS32::FieldS32(string hrName, int order, bool display, bool save, int32_t value, int32_t valueDefault)
        : FieldT<int32_t>(std::move(hrName), order, display, save),
          valueS32_(value),
          defaultValueS32_(valueDefault)
{

}

FieldS32::FieldS32(string hrName, array<int, 5> orders, bool display, bool save, int32_t value, int32_t valueDefault)
        : FieldT<int32_t>(std::move(hrName), orders, display, save),
          valueS32_(value),
          defaultValueS32_(valueDefault)
{

}

ValueVariant & FieldS32::var()
{
    return valueS32_;
}

ValueVariant & FieldS32::defVar()
{
    return defaultValueS32_;
}

int32_t & FieldS32::val()
{
    return get<int32_t>(valueS32_);
}

int32_t & FieldS32::defVal()
{
    return get<int32_t>(defaultValueS32_);
}

const string FieldS32::str()
{
    string s = format("{:L}", val());
    return s;
}

FieldKind FieldS32::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldU32 ******************************/
FieldU32::FieldU32(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault)
        : FieldT<uint32_t>(std::move(hrName), order, display, save),
          valueU32_(value),
          defaultValueU32_(valueDefault)
{

}

FieldU32::FieldU32(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault)
        : FieldT<uint32_t>(std::move(hrName), orders, display, save),
          valueU32_(value),
          defaultValueU32_(valueDefault)
{

}

ValueVariant & FieldU32::var()
{
    return valueU32_;
}

ValueVariant & FieldU32::defVar()
{
    return defaultValueU32_;
}

uint32_t & FieldU32::val()
{
    return get<uint32_t>(valueU32_);
}

uint32_t & FieldU32::defVal()
{
    return get<uint32_t>(defaultValueU32_);
}

const string FieldU32::str()
{
    string s = format("{:L}", val());
    return s;
}

FieldKind FieldU32::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldU64 ******************************/
FieldU64::FieldU64(string hrName, int order, bool display, bool save, uint64_t value, uint64_t valueDefault)
        : FieldT<uint64_t>(std::move(hrName), order, display, save),
          valueU64_(value),
          defaultValueU64_(valueDefault)
{

}

FieldU64::FieldU64(string hrName, array<int, 5> orders, bool display, bool save, uint64_t value, uint64_t valueDefault)
        : FieldT<uint64_t>(std::move(hrName), orders, display, save),
          valueU64_(value),
          defaultValueU64_(valueDefault)
{

}

ValueVariant & FieldU64::var()
{
    return valueU64_;
}

ValueVariant & FieldU64::defVar()
{
    return defaultValueU64_;
}

uint64_t & FieldU64::val()
{
    return get<uint64_t>(valueU64_);
}

uint64_t & FieldU64::defVal()
{
    return get<uint64_t>(defaultValueU64_);
}

const string FieldU64::str()
{
    string s = format("{:L}", val());
    return s;
}

FieldKind FieldU64::kind()
{
    return FieldKind::Numeric;
}

/****************************** FieldF32 ******************************/
FieldF32::FieldF32(string hrName, int order, bool display, bool save, float_t value, float_t valueDefault)
        : FieldT<float_t>(std::move(hrName), order, display, save),
          valueF32_(value),
          defaultValueF32_(valueDefault)
{

}

FieldF32::FieldF32(string hrName, array<int, 5> orders, bool display, bool save, float_t value, float_t valueDefault)
        : FieldT<float_t>(std::move(hrName), orders, display, save),
          valueF32_(value),
          defaultValueF32_(valueDefault)
{

}

ValueVariant & FieldF32::var()
{
    return valueF32_;
}

ValueVariant & FieldF32::defVar()
{
    return defaultValueF32_;
}

float_t & FieldF32::val()
{
    return get<float_t>(valueF32_);
}

float_t & FieldF32::defVal()
{
    return get<float_t>(defaultValueF32_);
}

const string FieldF32::str()
{
    string s = format("{:.5f}", val());
    return s;
}

FieldKind FieldF32::kind()
{
    return FieldKind::Numeric;
}

/***************************** FieldBool *****************************/
FieldBool::FieldBool(string hrName, int order, bool display, bool save, uint8_t value, uint8_t valueDefault)
         : FieldT<uint8_t>(std::move(hrName), order, display, save),
           valueBool_(value),
           defaultValueBool_(valueDefault)
{

}

FieldBool::FieldBool(string hrName, array<int, 5> orders, bool display, bool save, uint8_t value, uint8_t valueDefault)
         : FieldT<uint8_t>(std::move(hrName), orders, display, save),
           valueBool_(value),
           defaultValueBool_(valueDefault)
{

}

ValueVariant & FieldBool::var()
{
    return valueBool_;
}

ValueVariant & FieldBool::defVar()
{
    return defaultValueBool_;
}

uint8_t & FieldBool::val()
{
    return get<uint8_t>(valueBool_);
}

uint8_t & FieldBool::defVal()
{
    return get<uint8_t>(defaultValueBool_);
}

const string FieldBool::str()
{
    uint8_t value = val();
    if (value == 0)
        return "false";
    else if (value == 1)
        return "true";
    //else
    return format("other value ({})", static_cast<int>(value));
}

FieldKind FieldBool::kind()
{
    return FieldKind::Boolean;
}

bool FieldBool::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::Boolean)
    {
        bool expected = (filterVal == "true" || filterVal == "yes");
        return (val() != 0) == expected;
    }
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", static_cast<int>(val())), filterVal);
    return false;
}

/*************************** FieldChecksum ***************************/
FieldChecksum::FieldChecksum(string hrName, int order, bool display, bool save, uint64_t value, uint64_t valueDefault)
             : FieldT<uint64_t>(std::move(hrName), order, display, save),
               valueChecksum_(value),
               defaultValueChecksum_(valueDefault)
{

}

FieldChecksum::FieldChecksum(string hrName, array<int, 5> orders, bool display, bool save, uint64_t value, uint64_t valueDefault)
             : FieldT<uint64_t>(std::move(hrName), orders, display, save),
               valueChecksum_(value),
               defaultValueChecksum_(valueDefault)
{

}

ValueVariant & FieldChecksum::var()
{
    return valueChecksum_;
}

ValueVariant & FieldChecksum::defVar()
{
    return defaultValueChecksum_;
}

uint64_t & FieldChecksum::val()
{
    return get<uint64_t>(valueChecksum_);
}

uint64_t & FieldChecksum::defVal()
{
    return get<uint64_t>(defaultValueChecksum_);
}

const string FieldChecksum::str()
{
    string s = format("0x{:X}", val());
    return s;
}

FieldKind FieldChecksum::kind()
{
    return FieldKind::Checksum;
}

/*************************** FieldDataBlob ***************************/
FieldDataBlob::FieldDataBlob(string hrName, int order, bool display, bool save, vector<char> value, vector<char> valueDefault,
                             uint32_t fixedSize)
             : FieldT<vector<char>>(std::move(hrName), order, display, save),
               valueDataBlob_(value),
               defaultValueDataBlob_(valueDefault),
               blobFixedSize_(fixedSize)
{
    if (fixedSize > kBlobSizeSafety)
    {
        cerr << "Warning: FieldDataBlob::FieldDataBlob(..., int order) was asked to allocate " << fixedSize
             << " bytes of space. Capping to " << kBlobSizeSafety << ".\n";
        fixedSize = kBlobSizeSafety;
    }
    get<vector<char>>(valueDataBlob_).resize(fixedSize, '\0');
}

FieldDataBlob::FieldDataBlob(string hrName, array<int, 5> orders, bool display, bool save, vector<char> value, vector<char> valueDefault,
                             uint32_t fixedSize)
             : FieldT<vector<char>>(std::move(hrName), orders, display, save),
               valueDataBlob_(value),
               defaultValueDataBlob_(valueDefault),
               blobFixedSize_(fixedSize)
{
    if (fixedSize > kBlobSizeSafety)
    {
        cerr << "Warning: FieldDataBlob::FieldDataBlob(..., array<> orders) was asked to allocate " << fixedSize
             << " bytes of space. Capping to " << kBlobSizeSafety << ".\n";
        fixedSize = kBlobSizeSafety;
    }
    get<vector<char>>(valueDataBlob_).resize(fixedSize, '\0');
}

ValueVariant & FieldDataBlob::var()
{
    return valueDataBlob_;
}

ValueVariant & FieldDataBlob::defVar()
{
    return defaultValueDataBlob_;
}

vector<char> & FieldDataBlob::val()
{
    return get<vector<char>>(valueDataBlob_);
}

vector<char> & FieldDataBlob::defVal()
{
    return get<vector<char>>(defaultValueDataBlob_);
}

const string FieldDataBlob::str()
{
    string s = format("{} bytes of data", size());
    
    int output = 0;
    s += " (";
    for (char c : val())
    {
        s += format("{:02X} ", static_cast<unsigned char>(c));
        output++;
        if (output >= 6)
        {
            s += "...";
            break;
        }
    }
    s += ")";

    return s;
}

uint32_t FieldDataBlob::size()
{
    return static_cast<uint32_t>(val().size());
}

uint32_t FieldDataBlob::fixedSize()
{
    return blobFixedSize_;
}

size_t FieldDataBlob::auxSize()
{
    return size();
}

void FieldDataBlob::setReservedSize(uint32_t fixedSize)
{
    if (fixedSize > kBlobSizeSafety)
    {
        cerr << "Warning: FieldDataBlob::setReservedSize() was asked to allocate " << fixedSize << " bytes of space. Capping to "
             << kBlobSizeSafety << ".\n";
        fixedSize = kBlobSizeSafety;
    }

    blobFixedSize_ = fixedSize;
    val().clear();
    val().resize(fixedSize, '\0');
}

void FieldDataBlob::trim(uint32_t newSize)
{
    if (newSize >= blobFixedSize_) return;
    blobFixedSize_ = newSize;
    val().resize(newSize);
}

FieldKind FieldDataBlob::kind()
{
    return FieldKind::Binary;
}

/*************************** FieldDataSpan ***************************/
FieldDataSpan::FieldDataSpan(string hrName, int order, bool display, bool save, span<char> value, span<char> valueDefault)
             : FieldT<span<char>>(std::move(hrName), order, display, save),
               valueDataSpan_(value),
               defaultValueDataSpan_(valueDefault)
{

}

FieldDataSpan::FieldDataSpan(string hrName, array<int, 5> orders, bool display, bool save, span<char> value, span<char> valueDefault)
             : FieldT<span<char>>(std::move(hrName), orders, display, save),
               valueDataSpan_(value),
               defaultValueDataSpan_(valueDefault)
{

}

ValueVariant & FieldDataSpan::var()
{
    return valueDataSpan_;
}

ValueVariant & FieldDataSpan::defVar()
{
    return defaultValueDataSpan_;
}

span<char> & FieldDataSpan::val()
{
    return get<span<char>>(valueDataSpan_);
}

span<char> & FieldDataSpan::defVal()
{
    return get<span<char>>(defaultValueDataSpan_);
}

const string FieldDataSpan::str()
{
    string s = format("{} bytes of data", size());

    return s;
}

FieldKind FieldDataSpan::kind()
{
    return FieldKind::Binary;
}

/**************************** FieldDate24 ****************************/
FieldDate24::FieldDate24(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), order, display, save),
             valueDate24_(value),
             defaultValueDate24_(valueDefault)
{

}

FieldDate24::FieldDate24(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), orders, display, save),
             valueDate24_(value),
             defaultValueDate24_(valueDefault)
{

}

ValueVariant & FieldDate24::var()
{
    return valueDate24_;
}

ValueVariant & FieldDate24::defVar()
{
    return defaultValueDate24_;
}

uint32_t & FieldDate24::val()
{
    return get<uint32_t>(valueDate24_);
}

uint32_t & FieldDate24::defVal()
{
    return get<uint32_t>(defaultValueDate24_);
}

const string FieldDate24::str()
{
    return DataIO::PrintDate24(val());
}

void FieldDate24::setFromString(string newVal)
{
    valueDate24_ = DataIO::IntFromDateStr(newVal);
}

FieldKind FieldDate24::kind()
{
    return FieldKind::Date;
}

bool FieldDate24::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    if (fvk == FilterValueKind::Textual)
        return str() == filterVal;
    return false;
}

/**************************** FieldDate32 ****************************/
FieldDate32::FieldDate32(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), order, display, save),
             valueDate32_(value),
             defaultValueDate32_(valueDefault)
{

}

FieldDate32::FieldDate32(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), orders, display, save),
             valueDate32_(value),
             defaultValueDate32_(valueDefault)
{

}

ValueVariant & FieldDate32::var()
{
    return valueDate32_;
}

ValueVariant & FieldDate32::defVar()
{
    return defaultValueDate32_;
}

uint32_t & FieldDate32::val()
{
    return get<uint32_t>(valueDate32_);
}

uint32_t & FieldDate32::defVal()
{
    return get<uint32_t>(defaultValueDate32_);
}

const string FieldDate32::str()
{
    return DataIO::PrintDate32(val());
}

FieldKind FieldDate32::kind()
{
    return FieldKind::Date;
}

bool FieldDate32::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    if (fvk == FilterValueKind::Textual)
        return str() == filterVal;
    return false;
}

/*************************** FieldFlagSet16 ***************************/
FieldFlagSet16::FieldFlagSet16(string hrName, int order, bool display, bool save, uint16_t value, uint16_t valueDefault,
                               MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint16_t>(std::move(hrName), order, display, save),
                valueFlagSet16_(value),
                defaultValueFlagSet16_(valueDefault),
                flagSetValues16_(valueMap),
                flagSetNames16_(nameMap)
{

}

FieldFlagSet16::FieldFlagSet16(string hrName, array<int, 5> orders, bool display, bool save, uint16_t value, uint16_t valueDefault,
                               MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint16_t>(std::move(hrName), orders, display, save),
                valueFlagSet16_(value),
                defaultValueFlagSet16_(valueDefault),
                flagSetValues16_(valueMap),
                flagSetNames16_(nameMap)
{

}

ValueVariant & FieldFlagSet16::var()
{
    return valueFlagSet16_;
}

ValueVariant & FieldFlagSet16::defVar()
{
    return defaultValueFlagSet16_;
}

uint16_t & FieldFlagSet16::val()
{
    return get<uint16_t>(valueFlagSet16_);
}

uint16_t & FieldFlagSet16::defVal()
{
    return get<uint16_t>(defaultValueFlagSet16_);
}

const string FieldFlagSet16::str()
{
    return DataIO::ListFlags(flagSetValues16_, flagSetNames16_, val());
}

bool FieldFlagSet16::has(uint32_t flagCode)
{
    return DataIO::TestFlag(flagSetValues16_, val(), flagCode);
}

MapCodeToName * FieldFlagSet16::flagNameMap()
{
    return flagSetNames16_;
}

void FieldFlagSet16::setFlagValueMap(MapCodeToVal * ptr)
{
    flagSetValues16_ = ptr;
}

void FieldFlagSet16::setFlagNameMap(MapCodeToName * ptr)
{
    flagSetNames16_ = ptr;
}

FieldKind FieldFlagSet16::kind()
{
    return FieldKind::FlagSet;
}

bool FieldFlagSet16::matchesFilter(const string & filterVal)
{
    if (classifyFilterValue(filterVal) != FilterValueKind::Flag)
        return false;

    if (filterVal == "has none")
        return val() == 0;

    if (flagSetNames16_ == nullptr || flagSetValues16_ == nullptr)
        return false;

    // Parse all conditions from the filter string; conditions are separated by " has:" or " has no:" and each one must be satisfied
    struct Condition
    {
        bool expectSet;
        string flagName;
    };
    vector<Condition> conditions;
    size_t pos = 0;
    while (pos < filterVal.size())
    {
        bool expectSet;
        size_t nameStart;
        if (filterVal.substr(pos, 7) == "has no:")
        {
            expectSet = false;
            nameStart = pos + 7;
        }
        else if (filterVal.substr(pos, 4) == "has:")
        {
            expectSet = true;
            nameStart = pos + 4;
        }
        else
            break; // unexpected token; stop parsing

        // Find the start of the next condition by looking for " has:" or " has no:"
        size_t nameEnd = filterVal.size();
        for (size_t i = nameStart; i < filterVal.size(); ++i)
        {
            if (filterVal[i] == ' ' && (filterVal.substr(i + 1, 4) == "has:" || filterVal.substr(i + 1, 7) == "has no:"))
            {
                nameEnd = i;
                break;
            }
        }

        conditions.push_back({expectSet, filterVal.substr(nameStart, nameEnd - nameStart)});
        pos = nameEnd + 1; // advance past the space between conditions
    }

    if (conditions.empty())
        return false;

    // All conditions must hold
    for (auto & cond : conditions)
    {
        bool found = false;
        for (auto & [code, name] : *flagSetNames16_)
        {
            if (name == cond.flagName)
            {
                found = true;
                if (not flagSetValues16_->contains(code))
                    return false;
                bool isSet = (val() & static_cast<uint32_t>(flagSetValues16_->at(code))) != 0;
                if (isSet != cond.expectSet)
                    return false;
                break;
            }
        }
        if (not found)
        {
            // Warn once per unknown flag name so the user knows to correct their filter string
            static set<string> warnedNames;
            if (not warnedNames.contains(cond.flagName))
            {
                warnedNames.insert(cond.flagName);
                cerr << "Warning: " << quoted(cond.flagName) << " is not a valid flag name for field " << quoted(name())
                     << ". Use the -- command to learn what flags are available.\n";
            }
            return false;
        }
    }
    return true;
}

/*************************** FieldFlagSet32 ***************************/
FieldFlagSet32::FieldFlagSet32(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault, MapCodeToVal * valueMap,
                               MapCodeToName * nameMap)
              : FieldT<uint32_t>(std::move(hrName), order, display, save),
                valueFlagSet32_(value),
                defaultValueFlagSet32_(valueDefault),
                flagSetValues32_(valueMap),
                flagSetNames32_(nameMap)
{

}

FieldFlagSet32::FieldFlagSet32(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault,
                               MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint32_t>(std::move(hrName), orders, display, save),
                valueFlagSet32_(value),
                defaultValueFlagSet32_(valueDefault),
                flagSetValues32_(valueMap),
                flagSetNames32_(nameMap)
{

}

ValueVariant & FieldFlagSet32::var()
{
    return valueFlagSet32_;
}

ValueVariant & FieldFlagSet32::defVar()
{
    return defaultValueFlagSet32_;
}

uint32_t & FieldFlagSet32::val()
{
    return get<uint32_t>(valueFlagSet32_);
}

uint32_t & FieldFlagSet32::defVal()
{
    return get<uint32_t>(defaultValueFlagSet32_);
}

const string FieldFlagSet32::str()
{
    return DataIO::ListFlags(flagSetValues32_, flagSetNames32_, val());
}

bool FieldFlagSet32::has(uint32_t flagCode)
{
    return DataIO::TestFlag(flagSetValues32_, val(), flagCode);
}

MapCodeToName * FieldFlagSet32::flagNameMap()
{
    return flagSetNames32_;
}

void FieldFlagSet32::setFlagValueMap(MapCodeToVal * ptr)
{
    flagSetValues32_ = ptr;
}

void FieldFlagSet32::setFlagNameMap(MapCodeToName * ptr)
{
    flagSetNames32_ = ptr;
}

FieldKind FieldFlagSet32::kind()
{
    return FieldKind::FlagSet;
}

bool FieldFlagSet32::matchesFilter(const string & filterVal)
{
    if (classifyFilterValue(filterVal) != FilterValueKind::Flag)
        return false;

    if (filterVal == "has none")
        return val() == 0;

    if (flagSetNames32_ == nullptr || flagSetValues32_ == nullptr)
        return false;

    // Parse all conditions from the filter string; conditions are separated by " has:" or " has no:" and each one must be satisfied
    struct Condition
    {
        bool expectSet;
        string flagName;
    };
    vector<Condition> conditions;
    size_t pos = 0;
    while (pos < filterVal.size())
    {
        bool expectSet;
        size_t nameStart;
        if (filterVal.substr(pos, 7) == "has no:")
        {
            expectSet = false;
            nameStart = pos + 7;
        }
        else if (filterVal.substr(pos, 4) == "has:")
        {
            expectSet = true;
            nameStart = pos + 4;
        }
        else
            break; // unexpected token; stop parsing

        // Find the start of the next condition by looking for " has:" or " has no:"
        size_t nameEnd = filterVal.size();
        for (size_t i = nameStart; i < filterVal.size(); ++i)
        {
            if (filterVal[i] == ' ' && (filterVal.substr(i + 1, 4) == "has:" || filterVal.substr(i + 1, 7) == "has no:"))
            {
                nameEnd = i;
                break;
            }
        }

        conditions.push_back({expectSet, filterVal.substr(nameStart, nameEnd - nameStart)});
        pos = nameEnd + 1; // advance past the space between conditions
    }

    if (conditions.empty())
        return false;

    // All conditions must hold
    for (auto & cond : conditions)
    {
        bool found = false;
        for (auto & [code, name] : *flagSetNames32_)
        {
            if (name == cond.flagName)
            {
                found = true;
                if (not flagSetValues32_->contains(code))
                    return false;
                bool isSet = (val() & static_cast<uint32_t>(flagSetValues32_->at(code))) != 0;
                if (isSet != cond.expectSet)
                    return false;
                break;
            }
        }
        if (not found)
        {
            // Warn once per unknown flag name so the user knows to correct their filter string
            static set<string> warnedNames;
            if (not warnedNames.contains(cond.flagName))
            {
                warnedNames.insert(cond.flagName);
                cerr << "Warning: " << quoted(cond.flagName) << " is not a valid flag name for field " << quoted(name())
                     << ". Use the -- command to learn what flags are available.\n";
            }
            return false;
        }
    }
    return true;
}

/***************************** FieldLink *****************************/
FieldLink::FieldLink(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault, uint32_t valueNew)
         : FieldT<uint32_t>(std::move(hrName), order, display, save),
           valueLink_(value),
           defaultValueLink_(valueDefault),
           newLink_(valueNew),
           linkUsed_(false)
{

}

FieldLink::FieldLink(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault, uint32_t valueNew)
         : FieldT<uint32_t>(std::move(hrName), orders, display, save),
           valueLink_(value),
           defaultValueLink_(valueDefault),
           newLink_(valueNew),
           linkUsed_(false)
{

}

ValueVariant & FieldLink::var()
{
    return valueLink_;
}

ValueVariant & FieldLink::defVar()
{
    return defaultValueLink_;
}

ValueVariant & FieldLink::newVar()
{
    return newLink_;
}

uint32_t & FieldLink::val()
{
    return get<uint32_t>(valueLink_);
}

uint32_t & FieldLink::defVal()
{
    return get<uint32_t>(defaultValueLink_);
}

const string FieldLink::str()
{
    string s = "unused";
    if (hasLink())
        s = format("index #{:L}", val());
    if (not linkedName_.empty())
        s += format(" ({})", linkedName_);
    else if (hasLink())
        s += " (not found in file)";
    return s;
}

string & FieldLink::linkedName()
{
    return linkedName_;
}

bool FieldLink::hasLink()
{
    return linkUsed_;
}

void FieldLink::resolveLink(const function<string(int)> lookupFn)
{
    if (val() & 1) // a field with value 01 00 00 00 on disk is a real link pointing to instance #0; an unused field would be 00 00 00 00
        linkUsed_ = true;
    val() >>= 8; // undo the "<< 8 + 1" that Bungie applied to index number when saving to disk
    if (linkUsed_)
        linkedName() = lookupFn(static_cast<int>(val())); // run our link index number through GameData's lookup facility to get an instance name
}

FieldKind FieldLink::kind()
{
    return FieldKind::Link;
}

bool FieldLink::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::Numeric)
    {
        if (not hasLink())
            return false;
        return numericMatch(format("{}", val()), filterVal);
    }
    if (fvk == FilterValueKind::Textual)
        return linkedName_ == filterVal;
    return false;
}

/**************************** FieldOffset ****************************/
FieldOffset::FieldOffset(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), order, display, save),
             valueOffset_(value),
             defaultValueOffset_(valueDefault)
{

}

FieldOffset::FieldOffset(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), orders, display, save),
             valueOffset_(value),
             defaultValueOffset_(valueDefault)
{

}

ValueVariant & FieldOffset::var()
{
    return valueOffset_;
}

ValueVariant & FieldOffset::defVar()
{
    return defaultValueOffset_;
}

uint32_t & FieldOffset::val()
{
    return get<uint32_t>(valueOffset_);
}

uint32_t & FieldOffset::defVal()
{
    return get<uint32_t>(defaultValueOffset_);
}

const string FieldOffset::str()
{
    string s = format("0x{:X}", val());
    return s;
}

uint32_t FieldOffset::getAuxOffset()
{
    return val();
}

FieldKind FieldOffset::kind()
{
    return FieldKind::Offset;
}

/**************************** FieldPadding ****************************/
FieldPadding::FieldPadding(string hrName, int order, bool display, bool save, vector<char> value, vector<char> valueDefault, uint32_t fixedSize)
            : FieldT<vector<char>>(std::move(hrName), order, display, save),
              valuePadding_(value),
              defaultValuePadding_(valueDefault),
              fixedSize_(fixedSize)
{
    if (fixedSize > kPaddingSizeSafety)
    {
        cerr << "Warning: FieldPadding::FieldPadding(..., int order) was asked to allocate " << fixedSize
             << " bytes of space. Capping to " << kPaddingSizeSafety << ".\n";
        fixedSize = kPaddingSizeSafety;
    }

    FieldPadding::val().resize(fixedSize, '\0'); // class qualification avoids the static analyzer complaining
}

FieldPadding::FieldPadding(string hrName, array<int, 5> orders, bool display, bool save, vector<char> value, vector<char> valueDefault,
                           uint32_t fixedSize)
            : FieldT<vector<char>>(std::move(hrName), orders, display, save),
              valuePadding_(value),
              defaultValuePadding_(valueDefault),
              fixedSize_(fixedSize)
{
    if (fixedSize > kPaddingSizeSafety)
    {
        cerr << "Warning: FieldPadding::FieldPadding(..., array<> orders) was asked to allocate " << fixedSize
             << " bytes of space. Capping to " << kPaddingSizeSafety << ".\n";
        fixedSize = kPaddingSizeSafety;
    }

    FieldPadding::val().resize(fixedSize, '\0');
}

ValueVariant & FieldPadding::var()
{
    return valuePadding_;
}

ValueVariant & FieldPadding::defVar()
{
    return defaultValuePadding_;
}

vector<char> & FieldPadding::val()
{
    return get<vector<char>>(valuePadding_);
}

vector<char> & FieldPadding::defVal()
{
    return get<vector<char>>(defaultValuePadding_);
}

const string FieldPadding::str()
{
    string s = "0x";
    
    int output = 0;
    for (char c : val())
    {
        s += format("{:02X}", static_cast<unsigned char>(c));
        output++;
        if (output >= 10)
        {
            s += "...";
            break;
        }
    }
    
    return s;
}

uint32_t FieldPadding::size()
{
    return fixedSize_;
}

uint32_t FieldPadding::fixedSize()
{
    return fixedSize_;
}

void FieldPadding::setFixedSize(uint32_t fixedSize)
{
    if (fixedSize > kPaddingSizeSafety)
    {
        cerr << "Warning: FieldPadding::setFixedSize() was asked to allocate " << fixedSize << " bytes of space. Capping to "
             << kPaddingSizeSafety << ".\n";
        fixedSize = kPaddingSizeSafety;
    }

    fixedSize_ = fixedSize;
    val().clear();
    val().resize(fixedSize, '\0');
}

FieldKind FieldPadding::kind()
{
    return FieldKind::Binary;
}

/**************************** FieldSize16 ****************************/
FieldSize16::FieldSize16(string hrName, int order, bool display, bool save, uint16_t value, uint16_t valueDefault)
           : FieldT<uint16_t>(std::move(hrName), order, display, save, uint16_t{}, valueDefault),
             valueSize16_(value),
             defaultValueSize16_(valueDefault)
{

}

FieldSize16::FieldSize16(string hrName, array<int, 5> orders, bool display, bool save, uint16_t value, uint16_t valueDefault)
           : FieldT<uint16_t>(std::move(hrName), orders, display, save, uint16_t{}, valueDefault),
             valueSize16_(value),
             defaultValueSize16_(valueDefault)
{

}

ValueVariant & FieldSize16::var()
{
    return valueSize16_;
}

ValueVariant & FieldSize16::defVar()
{
    return defaultValueSize16_;
}

uint16_t & FieldSize16::val()
{
    return get<uint16_t>(valueSize16_);
}

uint16_t & FieldSize16::defVal()
{
    return get<uint16_t>(defaultValueSize16_);
}

const string FieldSize16::str()
{
    string s = DataIO::PrintSize(val(), UnitSystem::Both);
    return s;
}

FieldKind FieldSize16::kind()
{
    return FieldKind::Numeric;
}

bool FieldSize16::matchesFilter(const string & filterVal)
{
    if (classifyFilterValue(filterVal) == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    return false;
}

/**************************** FieldSize32 ****************************/
FieldSize32::FieldSize32(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), order, display, save),
             valueSize32_(value),
             defaultValueSize32_(valueDefault)
{

}

FieldSize32::FieldSize32(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault)
           : FieldT<uint32_t>(std::move(hrName), orders, display, save),
             valueSize32_(value),
             defaultValueSize32_(valueDefault)
{

}

ValueVariant & FieldSize32::var()
{
    return valueSize32_;
}

ValueVariant & FieldSize32::defVar()
{
    return defaultValueSize32_;
}

uint32_t & FieldSize32::val()
{
    return get<uint32_t>(valueSize32_);
}

uint32_t & FieldSize32::defVal()
{
    return get<uint32_t>(defaultValueSize32_);
}

const string FieldSize32::str()
{
    string s = DataIO::PrintSize(val(), UnitSystem::Both, 1);
    return s;
}

FieldKind FieldSize32::kind()
{
    return FieldKind::Numeric;
}

bool FieldSize32::matchesFilter(const string & filterVal)
{
    if (classifyFilterValue(filterVal) == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    return false;
}

/**************************** FieldString ****************************/
FieldString::FieldString(string hrName, int order, bool display, bool save, string value, string valueDefault, uint32_t fullSize)
           : FieldT<string>(std::move(hrName), order, display, save),
             valueString_(value),
             defaultValueString_(valueDefault),
             fullSize_(fullSize)
{

}

FieldString::FieldString(string hrName, array<int, 5> orders, bool display, bool save, string value, string valueDefault, uint32_t fullSize)
           : FieldT<string>(std::move(hrName), orders, display, save),
             valueString_(value),
             defaultValueString_(valueDefault),
             fullSize_(fullSize)
{

}

ValueVariant & FieldString::var()
{
    return valueString_;
}

ValueVariant & FieldString::defVar()
{
    return defaultValueString_;
}

string & FieldString::val()
{
    return get<string>(valueString_);
}

string & FieldString::defVal()
{
    return get<string>(defaultValueString_);
}

const string FieldString::str()
{
    return val();
}

uint32_t FieldString::size()
{
    if (fullSize_)
        return fullSize_;

    return static_cast<uint32_t>(val().size());
}

void FieldString::setFullSize(uint32_t fullSize)
{
    fullSize_ = fullSize;
}

FieldKind FieldString::kind()
{
    return FieldKind::Textual;
}

/****************************** FieldTag ******************************/
FieldTag::FieldTag(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault, ByteOrder byteOrder)
        : FieldT<uint32_t>(std::move(hrName), order, display, save),
          valueTag_(value),
          defaultValueTag_(valueDefault),
          tagByteOrder_(byteOrder)
{

}

FieldTag::FieldTag(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault, ByteOrder byteOrder)
        : FieldT<uint32_t>(std::move(hrName), orders, display, save),
          valueTag_(value),
          defaultValueTag_(valueDefault),
          tagByteOrder_(byteOrder)
{

}

ValueVariant & FieldTag::var()
{
    return valueTag_;
}

ValueVariant & FieldTag::defVar()
{
    return defaultValueTag_;
}

uint32_t & FieldTag::val()
{
    return get<uint32_t>(valueTag_);
}

uint32_t & FieldTag::defVal()
{
    return get<uint32_t>(defaultValueTag_);
}

const string FieldTag::str()
{
    uint32_t fullTag = val();
    string s;

    if (tagByteOrder_ == ByteOrder::LE)
        s = format("{}{}{}{}", char(fullTag >> (8 * 3)), char(fullTag >> (8 * 2)), char(fullTag >> (8 * 1)), char(fullTag >> (8 * 0)));
    else
        s = format("{}{}{}{}", char(fullTag >> (8 * 0)), char(fullTag >> (8 * 1)), char(fullTag >> (8 * 2)), char(fullTag >> (8 * 3)));

    return s;
}

void FieldTag::setByteOrder(ByteOrder newOrder)
{
    tagByteOrder_ = newOrder;
}

void FieldTag::setFromString(string newVal, ByteOrder order)
{
    if (newVal.size() < 4)
    {
        val() = 0;
        return;
    }

    if (order == ByteOrder::LE)
        val() = static_cast<uint32_t>((uint8_t(newVal[3]) << 0) | (uint8_t(newVal[2]) << 8) | (uint8_t(newVal[1]) << 16)
                | (uint8_t(newVal[0]) << 24));
    else
        val() = static_cast<uint32_t>((uint8_t(newVal[0]) << 0) | (uint8_t(newVal[1]) << 8) | (uint8_t(newVal[2]) << 16)
                | (uint8_t(newVal[3]) << 24));
}

FieldKind FieldTag::kind()
{
    return FieldKind::Tag;
}

/*************************** FieldTypeCode8 ***************************/
FieldTypeCode8::FieldTypeCode8(string hrName, int order, bool display, bool save, uint8_t value, uint8_t valueDefault, MapCodeToVal * valueMap,
                               MapCodeToName * nameMap)
              : FieldT<uint8_t>(std::move(hrName), order, display, save),
                valueTypeCode8_(value),
                defaultValueTypeCode8_(valueDefault),
                typeCodeValues_(valueMap),
                typeCodeNames_(nameMap)
{

}

FieldTypeCode8::FieldTypeCode8(string hrName, array<int, 5> orders, bool display, bool save, uint8_t value, uint8_t valueDefault,
                               MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint8_t>(std::move(hrName), orders, display, save),
                valueTypeCode8_(value),
                defaultValueTypeCode8_(valueDefault),
                typeCodeValues_(valueMap),
                typeCodeNames_(nameMap)
{

}

ValueVariant & FieldTypeCode8::var()
{
    return valueTypeCode8_;
}

ValueVariant & FieldTypeCode8::defVar()
{
    return defaultValueTypeCode8_;
}

uint8_t & FieldTypeCode8::val()
{
    return get<uint8_t>(valueTypeCode8_);
}

uint8_t & FieldTypeCode8::defVal()
{
    return get<uint8_t>(defaultValueTypeCode8_);
}

const string FieldTypeCode8::str()
{
    return DataIO::GetTypeName(typeCodeNames_, static_cast<uint32_t>(code()));
}

int FieldTypeCode8::code()
{
    return static_cast<int>(DataIO::GetTypeCode(typeCodeValues_, val()));
}

void FieldTypeCode8::setTypeValueMap(MapCodeToVal * ptr)
{
    typeCodeValues_ = ptr;
}

void FieldTypeCode8::setTypeNameMap(MapCodeToName * ptr)
{
    typeCodeNames_ = ptr;
}

MapCodeToName * FieldTypeCode8::typeNameMap()
{
    return typeCodeNames_;
}

FieldKind FieldTypeCode8::kind()
{
    return FieldKind::TypeCode;
}

bool FieldTypeCode8::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::TypeCode)
    {
        if (filterVal.substr(0, 9) == "type not:")
            return str() != filterVal.substr(9);
        return str() == filterVal.substr(5); // strip "type:" prefix
    }
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", static_cast<int>(val())), filterVal);
    if (fvk == FilterValueKind::Textual)
        return str() == filterVal;
    return false;
}

/************************** FieldTypeCode16 **************************/
FieldTypeCode16::FieldTypeCode16(string hrName, int order, bool display, bool save, uint16_t value, uint16_t valueDefault,
                                 MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint16_t>(std::move(hrName), order, display, save),
                valueTypeCode16_(value),
                defaultValueTypeCode16_(valueDefault),
                typeCodeValues_(valueMap),
                typeCodeNames_(nameMap)
{

}

FieldTypeCode16::FieldTypeCode16(string hrName, array<int, 5> orders, bool display, bool save, uint16_t value, uint16_t valueDefault,
                                 MapCodeToVal * valueMap, MapCodeToName * nameMap)
              : FieldT<uint16_t>(std::move(hrName), orders, display, save),
                valueTypeCode16_(value),
                defaultValueTypeCode16_(valueDefault),
                typeCodeValues_(valueMap),
                typeCodeNames_(nameMap)
{

}

ValueVariant & FieldTypeCode16::var()
{
    return valueTypeCode16_;
}

ValueVariant & FieldTypeCode16::defVar()
{
    return defaultValueTypeCode16_;
}

uint16_t & FieldTypeCode16::val()
{
    return get<uint16_t>(valueTypeCode16_);
}

uint16_t & FieldTypeCode16::defVal()
{
    return get<uint16_t>(defaultValueTypeCode16_);
}

const string FieldTypeCode16::str()
{
    return DataIO::GetTypeName(typeCodeNames_, static_cast<uint32_t>(code()));
}

int FieldTypeCode16::code()
{
    return static_cast<int>(DataIO::GetTypeCode(typeCodeValues_, val()));
}

void FieldTypeCode16::setTypeValueMap(MapCodeToVal * ptr)
{
    typeCodeValues_ = ptr;
}

void FieldTypeCode16::setTypeNameMap(MapCodeToName * ptr)
{
    typeCodeNames_ = ptr;
}

MapCodeToName * FieldTypeCode16::typeNameMap()
{
    return typeCodeNames_;
}

FieldKind FieldTypeCode16::kind()
{
    return FieldKind::TypeCode;
}

bool FieldTypeCode16::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::TypeCode)
    {
        if (filterVal.substr(0, 9) == "type not:")
            return str() != filterVal.substr(9);
        return str() == filterVal.substr(5);
    }
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    if (fvk == FilterValueKind::Textual)
        return str() == filterVal;
    return false;
}

/************************** FieldTypeCode32 **************************/
FieldTypeCode32::FieldTypeCode32(string hrName, int order, bool display, bool save, uint32_t value, uint32_t valueDefault,
                                 MapCodeToVal * valueMap, MapCodeToName * nameMap)
               : FieldT<uint32_t>(std::move(hrName), order, display, save),
                 valueTypeCode32_(value),
                 defaultValueTypeCode32_(valueDefault),
                 typeCodeValues_(valueMap),
                 typeCodeNames_(nameMap)
{

}

FieldTypeCode32::FieldTypeCode32(string hrName, array<int, 5> orders, bool display, bool save, uint32_t value, uint32_t valueDefault,
                                 MapCodeToVal * valueMap, MapCodeToName * nameMap)
               : FieldT<uint32_t>(std::move(hrName), orders, display, save),
                 valueTypeCode32_(value),
                 defaultValueTypeCode32_(valueDefault),
                 typeCodeValues_(valueMap),
                 typeCodeNames_(nameMap)
{

}

ValueVariant & FieldTypeCode32::var()
{
    return valueTypeCode32_;
}

ValueVariant & FieldTypeCode32::defVar()
{
    return defaultValueTypeCode32_;
}

uint32_t & FieldTypeCode32::val()
{
    return get<uint32_t>(valueTypeCode32_);
}

uint32_t & FieldTypeCode32::defVal()
{
    return get<uint32_t>(defaultValueTypeCode32_);
}

const string FieldTypeCode32::str()
{
    return DataIO::GetTypeName(typeCodeNames_, static_cast<uint32_t>(code()));
}

int FieldTypeCode32::code()
{
    return static_cast<int>(DataIO::GetTypeCode(typeCodeValues_, val()));
}

void FieldTypeCode32::setTypeValueMap(MapCodeToVal * ptr)
{
    typeCodeValues_ = ptr;
}

void FieldTypeCode32::setTypeNameMap(MapCodeToName * ptr)
{
    typeCodeNames_ = ptr;
}

MapCodeToName * FieldTypeCode32::typeNameMap()
{
    return typeCodeNames_;
}

FieldKind FieldTypeCode32::kind()
{
    return FieldKind::TypeCode;
}

bool FieldTypeCode32::matchesFilter(const string & filterVal)
{
    FilterValueKind fvk = classifyFilterValue(filterVal);
    if (fvk == FilterValueKind::TypeCode)
    {
        if (filterVal.substr(0, 9) == "type not:")
            return str() != filterVal.substr(9);
        return str() == filterVal.substr(5);
    }
    if (fvk == FilterValueKind::Numeric)
        return numericMatch(format("{}", val()), filterVal);
    if (fvk == FilterValueKind::Textual)
        return str() == filterVal;
    return false;
}