entry.cpp

Go to the documentation of this file.

#include "./entry.h"
#include "./parsingexception.h"
 
#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
 
#include <algorithm>
#include <sstream>
 
using namespace std;
using namespace CppUtilities;
 
namespace Io {
 
Entry::Entry(const string &label, NodeEntry *parent)
    : m_parent(nullptr)
    , m_index(-1)
{
    setParent(parent);
    setLabel(label);
}
 
Entry::Entry(const Entry &other)
    : m_label(other.m_label)
    , m_parent(nullptr)
    , m_index(-1)
{
}
 
Entry::~Entry()
{
    setParent(nullptr);
}
 
void Entry::makeLabelUnique()
{
    if (!m_parent) {
        return;
    }
    string newLabel(label());
    for (unsigned int index = 2;; ++index) {
        bool needsNewLabel = false;
        for (Entry *const sibling : m_parent->children()) {
            if (sibling == this || newLabel != sibling->label()) {
                continue;
            }
            needsNewLabel = true;
            newLabel = argsToString(label(), ' ', index);
            break;
        }
        if (!needsNewLabel) {
            break;
        }
    }
    m_label.swap(newLabel);
}
 
void Entry::setParent(NodeEntry *parent, int index)
{
    // skip if \a parent already assigned and the index doesn't change, too
    if (m_parent == parent && !(m_index != index && index >= 0)) {
        return;
    }
 
    // detach the current parent
    if (m_parent) {
        m_parent->m_children.erase(m_parent->m_children.begin() + m_index);
        for (auto i = m_parent->m_children.begin() + m_index; i < m_parent->m_children.end(); ++i) {
            (*i)->m_index -= 1;
        }
    }
 
    // attach the new parent
    if (parent) {
        if (index < 0 || static_cast<size_t>(index) >= parent->m_children.size()) {
            m_index = static_cast<int>(parent->m_children.size());
            parent->m_children.push_back(this);
        } else {
            for (auto i = parent->m_children.insert(parent->m_children.begin() + index, this) + 1; i != parent->m_children.end(); ++i) {
                (*i)->m_index += 1;
            }
            m_index = index;
        }
    } else {
        m_index = -1;
    }
 
    // actually assign the parent
    m_parent = parent;
 
    // ensure the label is still unique within the new parent
    makeLabelUnique();
}
 
bool Entry::isIndirectChildOf(const NodeEntry *entry) const
{
    if (!parent()) {
        return false;
    }
    if (parent() == entry) {
        return true;
    } else {
        return parent()->isIndirectChildOf(entry);
    }
}
 
std::list<string> Entry::path() const
{
    list<string> res;
    path(res);
    return res;
}
 
void Entry::path(std::list<string> &res) const
{
    if (m_parent) {
        m_parent->path(res);
    }
    res.push_back(label());
}
 
Entry *Entry::parse(istream &stream)
{
    const auto version = static_cast<std::uint8_t>(stream.peek());
    if (denotesNodeEntry(version)) {
        return new NodeEntry(stream);
    } else {
        return new AccountEntry(stream);
    }
}
 
NodeEntry::NodeEntry()
    : Entry()
    , m_expandedByDefault(true)
{
}
 
NodeEntry::NodeEntry(const string &label, NodeEntry *parent)
    : Entry(label, parent)
    , m_expandedByDefault(true)
{
}
 
NodeEntry::NodeEntry(istream &stream)
    : m_expandedByDefault(true)
{
    BinaryReader reader(&stream);
    const std::uint8_t version = reader.readByte();
    if (!denotesNodeEntry(version)) {
        throw ParsingException("Node entry expected.");
    }
    if (version != 0x0 && version != 0x1) {
        throw ParsingException("Entry version not supported.");
    }
    setLabel(reader.readLengthPrefixedString());
    // read extended header for version 0x1
    if (version == 0x1) {
        std::uint16_t extendedHeaderSize = reader.readUInt16BE();
        if (extendedHeaderSize >= 1) {
            std::uint8_t flags = reader.readByte();
            m_expandedByDefault = flags & 0x80;
            extendedHeaderSize -= 1;
        }
        m_extendedData = reader.readString(extendedHeaderSize);
    }
    const std::uint32_t childCount = reader.readUInt32BE();
    for (std::uint32_t i = 0; i != childCount; ++i) {
        Entry::parse(stream)->setParent(this);
    }
}
 
NodeEntry::NodeEntry(const NodeEntry &other)
    : Entry(other)
{
    for (Entry *const otherChild : other.m_children) {
        Entry *clonedChild = otherChild->clone();
        clonedChild->m_parent = this;
        clonedChild->m_index = static_cast<int>(m_children.size());
        m_children.push_back(clonedChild);
    }
}
 
NodeEntry::~NodeEntry()
{
    for (Entry *const child : m_children) {
        child->m_parent = nullptr;
        delete child;
    }
}
 
void NodeEntry::deleteChildren(int begin, int end)
{
    const auto endIterator = m_children.begin() + end;
 
    // delete the children
    for (auto iterator = m_children.cbegin() + begin; iterator != endIterator; ++iterator) {
        (*iterator)->m_parent = nullptr;
        delete *iterator;
    }
 
    // remove the children from the list
    m_children.erase(m_children.begin() + begin, endIterator);
 
    // adjust indices of subsequent children
    const int diff = end - begin;
    for (auto iterator = m_children.begin() + begin, end2 = m_children.end(); iterator != end2; ++iterator) {
        (*iterator)->m_index -= diff;
    }
}
 
void NodeEntry::replaceChild(size_t at, Entry *newChild)
{
    if (at >= m_children.size()) {
        return;
    }
 
    // detach the old child
    m_children[at]->m_parent = nullptr;
    m_children[at]->m_index = -1;
 
    // detach new child from its previous parent
    if (auto *newChildOldParent = newChild->m_parent) {
        newChildOldParent->m_children.erase(newChildOldParent->m_children.begin() + newChild->m_index);
        for (auto i = newChildOldParent->m_children.begin() + newChild->m_index; i < newChildOldParent->m_children.end(); ++i) {
            (*i)->m_index -= 1;
        }
    }
 
    // do the actual assignment
    newChild->m_parent = this;
    newChild->m_index = static_cast<int>(at);
    m_children[at] = newChild;
}
 
Entry *NodeEntry::entryByPath(list<string> &path, bool includeThis, const EntryType *creationType)
{
    if (path.empty()) {
        return nullptr;
    }
 
    // check for current instance
    if (includeThis) {
        if (path.front() == label()) {
            path.pop_front();
        } else {
            return nullptr;
        }
    }
    if (path.empty()) {
        return this;
    }
 
    for (Entry *const child : m_children) {
        if (path.front() != child->label()) {
            continue;
        }
        path.pop_front();
        if (path.empty()) {
            return child;
        } else if (child->type() == EntryType::Node) {
            return static_cast<NodeEntry *>(child)->entryByPath(path, false, creationType);
        } else {
            return nullptr; // can not resolve path since an account entry can not have children
        }
    }
 
    // create a new entry
    if (!creationType || path.size() != 1) {
        return nullptr;
    }
    switch (*creationType) {
    case EntryType::Account:
        return new AccountEntry(path.front(), this);
    case EntryType::Node:
        return new NodeEntry(path.front(), this);
    }
    return nullptr;
}
 
void NodeEntry::make(ostream &stream) const
{
    BinaryWriter writer(&stream);
    writer.writeByte(isExpandedByDefault() && m_extendedData.empty() ? 0x0 : 0x1); // version
    writer.writeLengthPrefixedString(label());
    if (!isExpandedByDefault() || !m_extendedData.empty()) {
        writer.writeUInt16BE(static_cast<std::uint16_t>(1 + m_extendedData.size())); // extended header is 1 byte long
        std::uint8_t flags = 0x00;
        if (isExpandedByDefault()) {
            flags |= 0x80;
        }
        writer.writeByte(flags);
        writer.writeString(m_extendedData);
    }
    writer.writeUInt32BE(static_cast<std::uint32_t>(m_children.size()));
    for (const Entry *const child : m_children) {
        child->make(stream);
    }
}
 
NodeEntry *NodeEntry::clone() const
{
    return new NodeEntry(*this);
}
 
void NodeEntry::accumulateStatistics(EntryStatistics &stats) const
{
    ++stats.nodeCount;
    for (const auto *children : children()) {
        children->accumulateStatistics(stats);
    }
}
 
AccountEntry::AccountEntry()
{
}
 
AccountEntry::AccountEntry(const string &label, NodeEntry *parent)
    : Entry(label, parent)
{
}
 
AccountEntry::AccountEntry(istream &stream)
{
    BinaryReader reader(&stream);
    std::uint8_t version = reader.readByte();
    if (denotesNodeEntry(version)) {
        throw ParsingException("Account entry expected.");
    }
    version ^= 0x80; // set first bit to zero
    if (version != 0x0 && version != 0x1) {
        throw ParsingException("Entry version not supported.");
    }
    setLabel(reader.readLengthPrefixedString());
    // read extended header for version 0x1
    if (version == 0x1) {
        const std::uint16_t extendedHeaderSize = reader.readUInt16BE();
        // currently there's nothing to read here
        m_extendedData = reader.readString(extendedHeaderSize);
    }
    const std::uint32_t fieldCount = reader.readUInt32BE();
    for (std::uint32_t i = 0; i != fieldCount; ++i) {
        m_fields.push_back(Field(this, stream));
    }
}
 
AccountEntry::AccountEntry(const AccountEntry &other)
    : Entry(other)
{
    m_fields = other.m_fields;
}
 
AccountEntry::~AccountEntry()
{
}
 
void AccountEntry::make(ostream &stream) const
{
    BinaryWriter writer(&stream);
    writer.writeByte(0x80 | (m_extendedData.empty() ? 0x0 : 0x1)); // version
    writer.writeLengthPrefixedString(label());
    if (!m_extendedData.empty()) {
        writer.writeUInt16BE(static_cast<std::uint16_t>(m_extendedData.size()));
        writer.writeString(m_extendedData);
    }
    writer.writeUInt32BE(static_cast<std::uint32_t>(m_fields.size()));
    for (const Field &field : m_fields) {
        field.make(stream);
    }
}
 
AccountEntry *AccountEntry::clone() const
{
    return new AccountEntry(*this);
}
 
void AccountEntry::accumulateStatistics(EntryStatistics &stats) const
{
    stats.accountCount += 1;
    stats.fieldCount += fields().size();
}
} // namespace Io