DecisionTreeBinarySerializer.hh

#ifndef GRAIL_DECISION_TREE_BINARY_SERIALIZER_H
#define GRAIL_DECISION_TREE_BINARY_SERIALIZER_H
 
#include "IDecisionTreeSerializer.hh"
#include "IDecisionSerializers.hh"
#include <iostream>
namespace grail
{
    namespace simulation
    {
        template <class TDecisionType>
        class DecisionTreeBinarySerializer : public IDecisionTreeSerializer<TDecisionType>
        {
        public:
            
            DecisionTreeBinarySerializer(std::unique_ptr<IDecisionBinarySerializer<TDecisionType>> actionSerializer, std::ostream* outStream) :
                outStream { outStream},
                inStream { nullptr},
                actionSerializer { std::move(actionSerializer)}
            {
 
            }
 
 
            DecisionTreeBinarySerializer(std::unique_ptr<IDecisionBinarySerializer<TDecisionType>> actionSerializer, std::istream* inStream) :
                outStream{ nullptr },
                inStream{ inStream },
                actionSerializer{ std::move(actionSerializer) }
            {
 
            }
 
            template<class T>
            void Write(T val)
            {
                outStream->write(reinterpret_cast<char*>(&val), sizeof(val));
            }
 
            template<class T>
            T Read()
            {
                char m[sizeof(size_t)];
                inStream->read(m, sizeof(T));
                T* val = reinterpret_cast<T*>(m);
                return *val;
            }
 
            virtual void SerializeNodeType(DecisionNodeType nodeType) override
            {
                Write(static_cast<int>(nodeType));              
            }
 
            virtual DecisionNodeType DeserializeNodeType() override
            {
                int i = Read<int>();
                if (i == 0)
                    return DecisionNodeType::NOMINAL_INNER;
                else if (i == 1)
                    return DecisionNodeType::CONTINUOUS_INNER;
                else
                    return DecisionNodeType::LEAF;
            }
 
            virtual void SerializeColumnIndex(int columnIndex) override
            {
                Write(columnIndex);
            }
 
            virtual int DeserializeColumnIndex() override
            {
                return Read<int>();
            }
 
            virtual void SerializeValue(float value) override
            {
                Write(value);
            }
 
            virtual float DeserializeValue() override
            {
                return Read<float>();
 
            }
 
            virtual void SerializeChildrenCount(int count) override
            {
                Write(count);
 
            }
 
            virtual int DeserializeChildrenCount() override
            {
                return Read<int>();
 
            }
 
            virtual void SerializeDecision(const TDecisionType& decision) override
            {
                actionSerializer->Serialize(decision, *outStream);
            }
 
            virtual std::unique_ptr<TDecisionType> DeserializeDecision() override
            {
                return actionSerializer->Deserialize(*inStream);
            }
 
        private:
            std::ostream* outStream;
            std::istream* inStream;
            std::unique_ptr<IDecisionBinarySerializer<TDecisionType>> actionSerializer;
 
        };
    }
}
#endif //GRAIL_DECISION_TREE_BINARY_SERIALIZER_H