IDecisionTreeSerializer.hh

#ifndef GRAIL_IDECISION_TREE_SERIALIZER_H
#define GRAIL_IDECISION_TREE_SERIALIZER_H
 
#include "../DT/ContinuousInnerDecisionNode.h"
#include "../DT/NominalInnerDecisionNode.h"
#include "../DT/LeafDecisionNode.h"
#include "../DT/DecisionNodeType.h"
#include "IDecisionSerializers.hh"
#include <memory>
 
namespace grail
{
 namespace simulation
 {
 template <class TDecisionType>
 struct IDecisionTreeSerializer
 {
 virtual void SerializeNodeType(DecisionNodeType nodeType) = 0;
 virtual DecisionNodeType DeserializeNodeType() = 0;
 
 virtual void SerializeColumnIndex(int columnIndex) = 0;
 virtual int DeserializeColumnIndex() = 0;
 
 virtual void SerializeValue(float value) = 0;
 virtual float DeserializeValue() = 0;
 
 virtual void SerializeChildrenCount(int count) = 0;
 virtual int DeserializeChildrenCount() = 0;
 
 virtual void SerializeDecision(const TDecisionType& decision) = 0;
 virtual std::unique_ptr<TDecisionType> DeserializeDecision() = 0;
 
 virtual void Initialize()
 {
 
 }
 
 void Serialize(DecisionNode<TDecisionType>& node)
 {
 switch (node.GetNodeType())
 {
 case DecisionNodeType::NOMINAL_INNER:
 SerializeNominalInnerDecisionNode(static_cast<NominalInnerDecisionNode<TDecisionType>&>(node));
 break;
 case DecisionNodeType::CONTINUOUS_INNER:
 SerializeContinuousInnerDecisionNode(static_cast<ContinuousInnerDecisionNode<TDecisionType>&>(node));
 break;
 case DecisionNodeType::LEAF:
 SerializeLeafNode(static_cast<LeafDecisionNode<TDecisionType>&>(node));
 break;
 default:
 break;
 }
 }
 
 void SerializeContinuousInnerDecisionNode(ContinuousInnerDecisionNode<TDecisionType>& node)
 {
 SerializeNodeType(DecisionNodeType::CONTINUOUS_INNER);
 SerializeColumnIndex(node.columnIndex);
 SerializeValue(node.splitValue);
 Serialize(*node.children[0]);
 Serialize(*node.children[1]);
 }
 
 void SerializeNominalInnerDecisionNode(NominalInnerDecisionNode<TDecisionType>& node)
 {
 SerializeNodeType(DecisionNodeType::NOMINAL_INNER);
 SerializeColumnIndex(node.columnIndex);
 SerializeChildrenCount(static_cast<int>(node.children.size()));
 for (auto& entry : node.children)
 {
 SerializeValue(entry.first);
 Serialize(*entry.second);
 }
 }
 
 void SerializeLeafNode(LeafDecisionNode<TDecisionType>& node)
 {
 SerializeNodeType(DecisionNodeType::LEAF);
 SerializeDecision(*node.decision);
 }
 
 void DeserializeContinuousInnerDecisionNode(ContinuousInnerDecisionNode<TDecisionType>& node)
 {
 node.children.emplace_back(std::move(DeserializeNode()));
 node.children.emplace_back(std::move(DeserializeNode()));
 }
 
 void DeserializeNominalInnerDecisionNode(NominalInnerDecisionNode<TDecisionType>& node)
 {
 int childrenCount = DeserializeColumnIndex();
 for (int i = 0; i < childrenCount; ++i)
 {
 float value = DeserializeValue();
 node.children[value] = DeserializeNode(); 
 }
 }
 
 std::unique_ptr<DecisionNode<TDecisionType>> DeserializeNode()
 {
 DecisionNodeType type = DeserializeNodeType();
 int columIndex = -1;
 switch (type)
 {
 case DecisionNodeType::NOMINAL_INNER:
 {
 columIndex = DeserializeColumnIndex();
 std::unique_ptr<NominalInnerDecisionNode<TDecisionType>> node = std::make_unique<NominalInnerDecisionNode<TDecisionType>>(columIndex);
 DeserializeNominalInnerDecisionNode(*node);
 return node;
 }
 case DecisionNodeType::CONTINUOUS_INNER:
 { 
 columIndex = DeserializeColumnIndex();
 float value = DeserializeValue();
 auto node = std::make_unique<ContinuousInnerDecisionNode<TDecisionType>>(columIndex, value);
 DeserializeContinuousInnerDecisionNode(*node);
 return node;
 }
 case DecisionNodeType::LEAF:
 {
 return std::make_unique<LeafDecisionNode<TDecisionType>>(DeserializeDecision());
 }
 default:
 return nullptr;
 }
 }
 };
 }
}
#endif //GRAIL_IDECISION_TREE_SERIALIZER_H