node.h

Go to the documentation of this file.

#pragma once
#include <iterator>
#include <memory>
#include <sstream>
#include "type_converter.h"

BEGIN_NAMESPACE_SERIALIZATION

class Node;
using NodePtr = std::shared_ptr<Node>;

class Node
{
public:
    
    virtual ~Node() = default;

    virtual void destroy() = 0;

    template <typename T>
    void addAttribute(const std::string& name, const T& value);

    template <typename T>
    void write(const std::string& name, const T& value);

    template <typename T, typename U>
    void write(const std::string& name, const T& value, const U& defaultValue);

    template <typename T>
    void read(const std::string& name, T& value);

    template <typename T, typename U>
    void read(const std::string& name, T& value, const U& defaultValue);

    template <typename T>
    void update(const std::string& name, T& value);

    template <typename T, typename U>
    void update(const std::string& name, T& value, const U& defaultValue);

    virtual NodePtr updateChild(const std::string& childName) = 0;

    virtual NodePtr readChild(const std::string& childName) = 0;
    
    virtual NodePtr createNode(std::string name, std::string value) = 0;

    virtual void initializeNode(std::string name, std::string value) = 0;

    virtual void initializeNode(NodePtr node) = 0;

    virtual void setValue(std::string value) = 0;

    virtual NodePtr addChild(std::string name) = 0;

    virtual NodePtr addChild(const NodePtr& childNode) = 0;
        
    virtual NodePtr clone() = 0;

    NodePtr clone(const NodePtr& nodeToClone);

    virtual NodePtr addAttributeNode(const NodePtr& attributeNode) = 0;

    virtual void clearChildNodes() = 0;

    virtual void clearAttributeNodes() = 0;

    virtual NodePtr findChildNode(const std::string& name) = 0;
       
    virtual NodePtr findAttributeNode(const std::string& name) = 0;

    virtual NodePtr getAttribute(const size_t attributeIndex) = 0;

    virtual NodePtr getChild(const size_t childIndex) = 0;

    virtual size_t getAttributeCount() = 0;

    virtual size_t getChildCount() = 0;

    virtual void removeAttribute(const std::string& attributeName) = 0;

    virtual void removeAttribute(const size_t attributeIndex) = 0;

    virtual void removeAttribute(NodePtr& attributeNode) = 0;

    virtual void removeChild(const std::string& childName) = 0;

    virtual void removeChild(const size_t childIndex) = 0;

    virtual void removeChild(NodePtr& childNode) = 0;

    virtual std::string getName() = 0;

    virtual std::string getValue() = 0;

    virtual NodePtr getNextSibling() = 0;

    virtual void updateOperation(bool write) = 0;

    virtual bool isWrite() = 0;

    virtual bool isInitialized() = 0;

    virtual bool isEmpty() = 0;

    bool isDummy() const;

    

protected:
    virtual void internalWrite(const std::string& name, const std::string& value, const std::string& defaultValue) = 0;
    virtual void internalRead(const std::string& name, std::string& value, const std::string& defaultValue) = 0; 
    virtual void internalAddAttribute(const std::string& name, const std::string& value) = 0;

    // Variable is set to true if node was created as a dummy node in an updateChild function when operation type was read and child was not found
    bool isDummyNode = false;
    
private:
    const std::string defaultStringValue = "";

    // Variable is used when write is called without default value, so that written value and default value are always different and node is always created.
    const std::string dummyString = "#";
        
    template <typename Iterator>
    void writeIterable(const std::string& name, Iterator first, Iterator last);

    template <typename Iterator>
    void readIterable(const std::string& name, Iterator first, Iterator last);

    template <typename OutputIterator>
    void readIterable(const std::string& name, OutputIterator output);

    template <typename T>
    typename std::enable_if<!is_container<T>::value>::type properTypeWrite(const std::string& name, const T& value)
    {
        const std::string valueString = TypeConverter<T>::toString(value);
        
        //Dummy string is added so that valueString and defaultValueString are always different and node is always created.
        const std::string defaultValueString = valueString + this->dummyString;
        internalWrite(name, valueString, defaultValueString);
    }

    template <typename T>
    typename std::enable_if<is_container<T>::value>::type properTypeWrite(const std::string& name, const T& value)
    {
        writeIterable(name, ContainerInputIterators<T>::begin(value), ContainerInputIterators<T>::end(value));
    }

    template <typename T>
    typename std::enable_if<!is_container<T>::value>::type properTypeRead(const std::string& name, T& value)
    {
        TypeConverter<T> defaultBaseTypeValue;
        const std::string defaultValueString = TypeConverter<T>::toString(defaultBaseTypeValue.defaultValue);
        std::string outputValueString;
        
        try
        {
            internalRead(name, outputValueString, defaultValueString);
            value = static_cast<T>(TypeConverter<T>::convertStringToProperType(outputValueString));
        }
        catch (std::invalid_argument&)
        {
            throw XmlException(XmlExceptionCode::xecNodeDoesNotContainExpectedType);
        }
        catch (std::out_of_range&)
        {
            throw XmlException(XmlExceptionCode::xecValueIsOutOfRange);
        }
    }

    template <typename T>
    typename std::enable_if<is_container<T>::value>::type properTypeRead(const std::string& name, T& value)
    {
        properContainerTypeRead(name, value);
    }

    template <typename T>
    typename std::enable_if<has_back_insert<T>::value>::type properContainerTypeRead(const std::string& name, T& value)
    {
        readIterable(name, std::back_insert_iterator<T>(value));
    }

    template <typename T>
    typename std::enable_if<!has_back_insert<T>::value>::type properContainerTypeRead(const std::string& name, T& value)
    {
        readIterable(name, ContainerOutputIterators<T>::begin(value), ContainerOutputIterators<T>::end(value));
    }

    virtual NodePtr addUniqueChild(const std::string& name) = 0;
};

template <typename T>
void Node::write(const std::string& name, const T& value)
{
    properTypeWrite(name, value);
}

template <typename T, typename U>
void Node::write(const std::string& name, const T& value, const U& defaultValue)
{
    const std::string valueString = TypeConverter<T>::toString(value);
    const std::string defaultValueString = TypeConverter<U>::toString(defaultValue);
    internalWrite(name, valueString, defaultValueString);
}

template <typename Iterator>
void Node::writeIterable(const std::string& name, Iterator first, Iterator last)
{
    const size_t size = std::distance(first, last);
    std::string inputValuesString;
    using IteratorValueType = typename std::iterator_traits<Iterator>::value_type;

    for (size_t i = 0; i < size; i++)
    {
        inputValuesString += TypeConverter<IteratorValueType>::toString(*first);
        inputValuesString += ";";
        ++first;
    }

    if (!inputValuesString.empty())
    {
        inputValuesString.pop_back();
    }
    internalWrite(name, inputValuesString, this->defaultStringValue);
}

template <typename T>
void Node::read(const std::string& name, T& value)
{
    properTypeRead(name, value);
}

template <typename T, typename U>
void Node::read(const std::string& name, T& value, const U& defaultValue)
{
    std::string outputValueString;
    const std::string defaultValueString = TypeConverter<U>::toString(defaultValue);
    
    try
    {
        internalRead(name, outputValueString, defaultValueString);
        value = static_cast<T>(TypeConverter<T>::convertStringToProperType(outputValueString));
    }
    catch (std::invalid_argument&)
    {
        throw XmlException(XmlExceptionCode::xecNodeDoesNotContainExpectedType);
    }
    catch (std::out_of_range&)
    {
        throw XmlException(XmlExceptionCode::xecValueIsOutOfRange);
    }
}

template <typename T>
void Node::update(const std::string& name, T& value)
{
    if (isWrite())
    {
        write(name, value); 
    }
    else
    {
        read(name, value);
    }
}

template <typename T, typename U>
void Node::update(const std::string& name, T& value, const U& defaultValue)
{
    if (isWrite())
    {
        write(name, value, defaultValue);
    }
    else
    {
        read(name, value, defaultValue);
    }
}

template <typename Iterator>
void Node::readIterable(const std::string& name, Iterator first, Iterator last)
{
    std::string outputValuesString;

    try
    {
        internalRead(name, outputValuesString, "");

        using IteratorValueType = typename std::iterator_traits<Iterator>::value_type;

        TypeConverter<IteratorValueType> defaultBaseTypeValue;
        std::stringstream valuesStringStream(outputValuesString);
        std::string stringSegment;

        const size_t size = std::distance(first, last);

        for (size_t i = 0; i < size; i++)
        {
            if (std::getline(valuesStringStream, stringSegment, ';'))
            {
                *first = static_cast<IteratorValueType>(TypeConverter<IteratorValueType>::convertStringToProperType(stringSegment));
            }
            else
            {
                *first = static_cast<IteratorValueType>(defaultBaseTypeValue.defaultValue);
            }
            ++first;
        }
    }
    catch (std::invalid_argument&)
    {
        throw XmlException(XmlExceptionCode::xecNodeDoesNotContainExpectedType);
    }
    catch (std::out_of_range&)
    {
        throw XmlException(XmlExceptionCode::xecValueIsOutOfRange);
    }
}


template <typename OutputIterator>
void Node::readIterable(const std::string& name, OutputIterator output)
{
    std::string outputValuesString;
    try
    {
        internalRead(name, outputValuesString, "");

        if (!outputValuesString.empty())
        {
            std::stringstream valuesStringStream(outputValuesString);
            std::string stringSegment;

            while (std::getline(valuesStringStream, stringSegment, ';'))
            {
                *output++ = static_cast<typename output_iterator_traits<OutputIterator>::value_type>(
                    TypeConverter<typename output_iterator_traits<OutputIterator>::value_type>::convertStringToProperType(stringSegment));
            }
        }
    }
    catch (std::invalid_argument&)
    {
        throw XmlException(XmlExceptionCode::xecNodeDoesNotContainExpectedType);
    }
    catch (std::out_of_range&)
    {
        throw XmlException(XmlExceptionCode::xecValueIsOutOfRange);
    }
}

template <typename T>
void Node::addAttribute(const std::string& name, const T& value)
{
    internalAddAttribute(name, TypeConverter<T>::toString(value));
}

END_NAMESPACE_SERIALIZATION