bag_valuetable.cpp

#include "bag_compounddatatype.h"
#include "bag_georefmetadatalayerdescriptor.h"
#include "bag_dataset.h"
#include "bag_exceptions.h"
#include "bag_hdfhelper.h"
#include "bag_private.h"
#include "bag_valuetable.h"

#include <algorithm>
#include <array>
#include <H5Cpp.h>


namespace BAG {

namespace {

//! Convert a chunk of memory and a definition into a Record.
/*!
\param buffer
    A chunk of memory representing a Record for a georeferenced metadata layer.
\param definition
    The definition of the Record for a georeferenced metadata layer.

\return
    A georeferenced metadata layer record using the buffer and definition.
*/
Record convertMemoryToRecord(
    const uint8_t* const buffer,
    const RecordDefinition& definition)
{
    if (!buffer)
        return {};

    Record record;
    record.reserve(definition.size());

    size_t fieldOffset = 0;

    for (const auto& field : definition)
    {
        const auto fieldType = static_cast<DataType>(field.type);
        CompoundDataType value;
        const char* str = nullptr;

        switch(fieldType)
        {
        case DT_BOOLEAN:
            value = *reinterpret_cast<const bool*>(buffer + fieldOffset);
            break;
        case DT_FLOAT32:
            value = *reinterpret_cast<const float*>(buffer + fieldOffset);
            break;
        case DT_UINT32:
            value = *reinterpret_cast<const uint32_t*>(buffer + fieldOffset);
            break;
        case DT_STRING:
        {
            const auto address =
                *reinterpret_cast<const std::uintptr_t*>(buffer + fieldOffset);
            str = reinterpret_cast<const char*>(address);
            value = std::string{str ? str : ""};

            // Clean up the char* allocated by HDF reading.
            free(const_cast<char*>(str));
            break;
        }
        case DT_UINT8:  //[[fallthrough]]
        case DT_UINT16:  //[[fallthrough]]
        case DT_UINT64:  //[[fallthrough]]
        case DT_COMPOUND:  //[[fallthrough]]
        case DT_UNKNOWN_DATA_TYPE:  //[[fallthrough]]
        default:
            throw UnsupportedDataType{};
        }

        record.emplace_back(value);
        fieldOffset += Layer::getElementSize(fieldType);
    }

    return record;
}

//! Convert a Record into a chunk of memory.
/*!
\param record
    The record to convert into a chunk of memory.
\param buffer
    The memory to store the record in.
*/
void convertRecordToMemory(
    const Record& record,
    uint8_t* buffer)
{
    size_t fieldOffset = 0;  // offset into buffer to the field

    for (const auto& field : record)
    {
        const auto fieldType = field.getType();
        switch(fieldType)
        {
        case DT_BOOLEAN:
            *reinterpret_cast<bool*>(buffer + fieldOffset) = field.asBool();
            break;
        case DT_FLOAT32:
            *reinterpret_cast<float*>(buffer + fieldOffset) = field.asFloat();
            break;
        case DT_UINT32:
            *reinterpret_cast<uint32_t*>(buffer + fieldOffset) = field.asUInt32();
            break;
        case DT_STRING:
        {
            *reinterpret_cast<char**>(buffer + fieldOffset) =
                const_cast<char*>(field.asString().data());
            break;
        }
        case DT_UINT8:  //[[fallthrough]]
        case DT_UINT16:  //[[fallthrough]]
        case DT_UINT64:  //[[fallthrough]]
        case DT_COMPOUND:  //[[fallthrough]]
        case DT_UNKNOWN_DATA_TYPE:  //[[fallthrough]]
        default:
            throw UnsupportedDataType{};
        }

        fieldOffset += Layer::getElementSize(fieldType);
    }
}

}  // namespace

//! Constructor.
/*!
\param layer
    The layer the value table holds records/values for.
*/
ValueTable::ValueTable(
    const GeorefMetadataLayer& layer)
    : m_layer(layer)
{
    // Read the Records DataSet.
    const auto& h5valueDataSet = m_layer.getValueDataSet();

    const auto fileDataSpace = h5valueDataSet.getSpace();
    hsize_t numRecords = 0;
    const auto numDims = fileDataSpace.getSimpleExtentDims(&numRecords);
    if (numDims != 1)
        throw InvalidValueSize{};

    m_records.resize(numRecords);

    if (numRecords == 1)  // No user defined records.
        return;

    constexpr hsize_t startIndex = 0;
    fileDataSpace.selectHyperslab(H5S_SELECT_SET, &numRecords, &startIndex);

    auto pDescriptor = std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
        m_layer.getDescriptor());
    const auto& definition = pDescriptor->getDefinition();

    const size_t recordSize = getRecordSize(definition);
    std::vector<uint8_t> buffer(recordSize * numRecords, 0);

    const auto memDataType = createH5memoryCompType(definition);
    const ::H5::DataSpace memDataSpace;
    memDataSpace.setExtentSimple(1, &numRecords);

    h5valueDataSet.read(buffer.data(), memDataType, memDataSpace, fileDataSpace);

    // Convert the raw memory into Records.
    size_t rawIndex = 0;

    for (auto& record : m_records)
    {
        record = convertMemoryToRecord(buffer.data() + (rawIndex * recordSize),
            definition);
        ++rawIndex;
    }
}

//! Add a record/value to the end of the list.
/*!
\param record
    The record/value.

\return
    The index of the added record.
*/
size_t ValueTable::addRecord(
    const Record& record)
{
    if (!this->validateRecord(record))
        throw InvalidValue{};

    const auto newKey = m_records.size();
    this->writeRecord(newKey, record);

    m_records.emplace_back(record);

    return newKey;
}

//! Add multiple records/values to the end of the list.
/*!
\param records
    The records/values.
*/
void ValueTable::addRecords(
    const Records& records)
{
    if (records.empty())
        return;

    const bool allValid = std::all_of(cbegin(records), cend(records),
        [this](const auto& record) {
            return this->validateRecord(record);
        });
    if (!allValid)
        throw InvalidValue{};

    this->writeRecords(records);

    m_records.insert(end(m_records), cbegin(records), cend(records));
}

//! Convert a record/value to a chunk of memory.
/*!
\param record
    The record/value to convert.

\return
    A copy of the record/value as a chunk of memory.
*/
std::vector<uint8_t> ValueTable::convertRecordToRaw(
    const Record& record) const
{
    auto pDescriptor =
        std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
            m_layer.getDescriptor());

    std::vector<uint8_t> buffer(getRecordSize(pDescriptor->getDefinition()), 0);

    convertRecordToMemory(record, buffer.data());

    return buffer;
}

//! Convert multiple records/values to a chunk of memory.
/*!
\param records
    The records/values to convert.

\return
    A copy of the records/values as a chunk of memory.
*/
std::vector<uint8_t> ValueTable::convertRecordsToRaw(
    const std::vector<Record>& records) const
{
    if (records.empty())
        return {};

    auto pDescriptor =
        std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
            m_layer.getDescriptor());

    const auto recordSize = getRecordSize(pDescriptor->getDefinition());
    std::vector<uint8_t> buffer(recordSize * records.size(), 0);

    // Write values into memory.
    size_t offset = 0;

    for (const auto& record : records)
    {
        convertRecordToMemory(record, buffer.data() + offset);
        offset += recordSize;
    }

    return buffer;
}

//! Retrieve the record/value definition.
/*!
\return
    The list of fields that define the record/value.
*/
const RecordDefinition& ValueTable::getDefinition() const & noexcept
{
    return std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
        m_layer.getDescriptor())->getDefinition();
}

//! Retrieve the value of a specific field in a specific record.
/*!
\param key
    The key of the record/value.
    Must be greater than 0.
\param name
    The name of the field.

\return
    The value specified.
    An exception is thrown if the key or field name is invalid.
*/
const CompoundDataType& ValueTable::getValue(
    size_t key,
    const std::string& name) const &
{
    if (key == 0 || key >= m_records.size())
        throw ValueNotFound{};

    const size_t fieldIndex = this->getFieldIndex(name);

    return this->getValue(key, fieldIndex);
}

//! Retrieve the value of a specific field in a specific record/value.
/*!
\param key
    The key of the record/value.
    Must be greater than 0.
\param fieldIndex
    The index of the field.

\return
    The value specified.
    An exception is thrown if the record index or field index are invalid.
*/
const CompoundDataType& ValueTable::getValue(
    size_t key,
    size_t fieldIndex) const &
{
    if (key == 0 || key >= m_records.size())
        throw ValueNotFound{};

    const auto& definition = this->getDefinition();
    if (fieldIndex >= definition.size())
        throw FieldNotFound{};

    const auto& record = m_records[key];

    return record[fieldIndex];
}

//! Retrieve the field index of the named field.
/*!
\param name
    The name of the field.

\return
    The field index of the named field.
*/
size_t ValueTable::getFieldIndex(
    const std::string& name) const
{
    const auto& definition = this->getDefinition();
    size_t fieldIndex = 0;

    for (const auto& field : definition)
    {
        if (name == field.name)
            return fieldIndex;

        ++fieldIndex;
    }

    throw FieldNotFound{};
}

//! Retrieve the field name of the indexed field.
/*!
\param index
    The index of the field.

\return
    The field name of the indexed field.
*/
const char* ValueTable::getFieldName(
    size_t index) const &
{
    const auto& definition = this->getDefinition();
    if (index >= definition.size())
        throw FieldNotFound{};

    return definition[index].name;
}

//! Retrieve all the records/values.
/*!
\return
    All the records/values.
    NOTE!  This includes the no data value record at index 0.
*/
const Records& ValueTable::getRecords() const & noexcept
{
    return m_records;
}

//! Set a value in a specific field in a specific record.
/*!
\param key
    The record/value key.
    Must be greater than 0.
\param name
    The name of the field.
\param value
    The value to put into the field.
*/
void ValueTable::setValue(
    size_t key,
    const std::string& name,
    const CompoundDataType& value)
{
    if (key == 0 || key >= m_records.size())
        throw ValueNotFound{};

    const size_t fieldIndex = this->getFieldIndex(name);

    this->setValue(key, fieldIndex, value);
}

//! Set a value in a specific field in a specific record.
/*!
\param key
    The record key.
    Must be greater than 0.
\param fieldIndex
    The index of the field.
\param value
    The value to put into the field.
*/
void ValueTable::setValue(
    size_t key,
    size_t fieldIndex,
    const CompoundDataType& value)
{
    if (key == 0 || key >= m_records.size())
        throw ValueNotFound{};

    auto& record = m_records[key];
    record[fieldIndex] = value;

    this->writeRecord(key, record);
}

//! Determine if the specified record/value matches the definition used by the value table.
/*!
\param record
    The record/value.

\return
    \e true if the record/value matches the definition.
    \e false otherwise
*/
bool ValueTable::validateRecord(
    const Record& record) const
{
    auto pDescriptor =
        std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
            m_layer.getDescriptor());
    if (!pDescriptor)
        throw InvalidDescriptor{};

    const auto& definition = pDescriptor->getDefinition();

    if (record.size() != definition.size())
        return false;

    size_t defIndex = 0;

    for (const auto& field : record)
    {
        const auto defType = static_cast<DataType>(definition[defIndex++].type);

        if (defType == DT_UNKNOWN_DATA_TYPE
            || field.getType() == DT_UNKNOWN_DATA_TYPE)
            return false;

        const auto fieldType = field.getType();
        if (fieldType != defType)
            return false;
    }

    return true;
}

//! Write a record/value to the HDF5 DataSet at the specified key.
/*!
\param key
    The record key.
    Must be greater than 0.
\param record
    The record/value to write.
*/
void ValueTable::writeRecord(
    size_t key,
    const Record& record)
{
    if (key == 0 || key > m_records.size())
        throw InvalidValueKey{};

    const hsize_t fileRecordIndex = key;

    // Prepare the memory details.
    const auto rawMemory = this->convertRecordToRaw(record);

    auto pDescriptor =
        std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
            m_layer.getDescriptor());

    const auto memDataType = createH5memoryCompType(pDescriptor->getDefinition());

    constexpr hsize_t one = 1;
    ::H5::DataSpace memDataSpace(1, &one, &one);

    // Prepare the file details.
    const auto& h5valueDataSet = m_layer.getValueDataSet();

    if (key == m_records.size())
    {
        // Make room for a new record.
        const hsize_t newNumRecords = fileRecordIndex + 1;
        h5valueDataSet.extend(&newNumRecords);
    }

    const auto fileDataSpace = h5valueDataSet.getSpace();

    // select the record to write
    fileDataSpace.selectElements(H5S_SELECT_SET, 1, &fileRecordIndex);

    h5valueDataSet.write(rawMemory.data(), memDataType, memDataSpace,
        fileDataSpace);
}

//! Write multiple records/values at the end of the list to the HDF5 DataSet.
/*!
\param records
    The records/values.
*/
void ValueTable::writeRecords(
    const std::vector<Record>& records)
{
    if (records.empty())
        return;

    // Prepare the memory details.
    const auto rawMemory = this->convertRecordsToRaw(records);

    auto pDescriptor =
        std::dynamic_pointer_cast<const GeorefMetadataLayerDescriptor>(
            m_layer.getDescriptor());

    const auto memDataType = createH5memoryCompType(pDescriptor->getDefinition());

    const hsize_t numRecords = records.size();
    ::H5::DataSpace memDataSpace(1, &numRecords, &numRecords);

    // Prepare the file details.
    const auto& h5valueDataSet = m_layer.getValueDataSet();

    // Make room for the new records.
    const hsize_t newNumRecords = m_records.size() + numRecords;
    h5valueDataSet.extend(&newNumRecords);

    const auto fileDataSpace = h5valueDataSet.getSpace();

    // Specify the key to begin writing to.
    const hsize_t keyToModify = m_records.size();
    fileDataSpace.selectHyperslab(H5S_SELECT_SET, &numRecords, &keyToModify);

    h5valueDataSet.write(rawMemory.data(), memDataType, memDataSpace,
        fileDataSpace);
}

}  // namespace BAG