@startuml
set namespaceSeparator ::
namespace dynasty {

namespace inferencer {
  abstract class PianoInferencer<T> {
   # {abstract} GraphBasedInference(unordered_map<string, vector<T>> const &preprocess_input) : unordered_map<string, vector<T>>
  }

  abstract class Builder {
    + {abstract} build() : unique_ptr<AbstractInferencer<T>, InferencerDeletor>
   }

  PianoInferencer +-- Builder

namespace common {

  abstract class BaseInferencerImpl<T> {
    # Initialize() : void
    # CleanUp() : void
    # GraphBasedInference(): void

    # {abstract} SetInitializeList() : void
    # {abstract} GetInitializeHeader() : AbstractHandler*
    # {abstract} SetCleanUpList() : void
    # {abstract} GetCleanUpList() : AbstractHandler*
    # {abstract} FillInputs() : void
    # {abstract} SetInferenceVisitor(): void
    # {abstract} GetInferenceVisitor(): AbstractInferenceVisitor*
    # {abstract} GetTensorCPUData(Node*) : vector<T>
  }

  note right of BaseInferencerImpl
  void Initialize() {
        SetInitializeList();
        SetInferenceVisitor();
        if (GetInitializeHeader() != nullptr) {
            GetInitializeHeader()->Handle();
        }
    }
  end note

  note right of BaseInferencerImpl
  void CleanUp() {
        SetCleanUpList();
        if (GetCleanUpList() != nullptr) {
            GetCleanUpList()->Handle();
        }
    }
  end note

  note left of BaseInferencerImpl
  std::unordered_map<string, vector<T>>
    GraphBasedInference(unordered_map<string, vector<T>> const &preprocess_input) override {
        FillInputs(preprocess_input);
        int index = 0;
        unordered_map<string, vector<T>> result;
        for (auto graph_iterator = PianoInferencer<T>::GetImmutableGraph()->begin();
             graph_iterator != PianoInferencer<T>::GetImmutableGraph()->end();
             ++graph_iterator, ++index) {
            graph_iterator->Accept(*GetInferenceVisitor());
        }
        return result;
    }
  end note

  abstract class Builder {
    # {abstract} GetBaseInferencerImplPtr() : BaseInferencerImpl*

    + build() : unique_ptr<AbstractInferencer<T>, InferencerDeletor>
   }

  note right of Builder
  InferencerUniquePtr<T> Build() {
      auto inferencer_ptr = GetBaseInferencerImplPtr();
      inferencer_ptr->Initialize();
      return InferencerUniquePtr<T>(inferencer_ptr);
  }
  end note

  BaseInferencerImpl +-- Builder

  dynasty::inferencer::PianoInferencer <|-- BaseInferencerImpl
  dynasty::inferencer::Builder <|-- Builder

  abstract class AbstractHandler {
    + {abstract} SetNext(AbstractHandler* ) : AbstractHandler*
    + {abstract} GetNext() : AbstractHandler*
    + {abstract} Handle() : void
  }

  abstract class BaseHandler {
    - next_ : AbstractHandler*

    # {abstract} handle() : void
    + GetNext() :  AbstractHandler*
  }

  note left of BaseHandler
    AbstractHandler* GetNext() override {
        return next_;
    }

    AbstractHandler* SetNext(AbstractHandler* handler) override {
        next_ = handler;
        return handler;
    }

    void Handle() override {
        handle();
        if (next_ != nullptr) {
            next_->Handle();
        }
    }
  end note

  AbstractHandler <|-- BaseHandler
} /'namespace common'/

namespace cpu {

class InferencerImpl {
  - inference_visitor_ : InferenceVisitorImpl<T> *
  - initialization_head_ : AbstractHandler *
  - clean_up_head_ : AbstractHandler *

  #  SetInitializeList() : void
  #  GetInitializeHeader() : AbstractHandler*
  #  SetCleanUpList() : void
  #  GetCleanUpList() : AbstractHandler*
  #  FillInputs() : void
  #  SetInferenceVisitor(): void
  #  GetInferenceVisitor(): AbstractInferenceVisitor*
  #  GetTensorCPUData(Node*) : vector<T>

  + {static} GetBuilder() : Builder*
}

note right of InferencerImpl
void SetInitializeList() {
    initialization_head_ = new SetCPUTensorVector<T>(node_ptr_to_tensor_cpu_vec_, BaseInferencerImpl<T>::GetImmutableGraph());
}

void SetInferenceVisitor() {
    inference_visitor_ = new InferenceVisitorImpl<T>(node_ptr_to_tensor_cpu_vec_);
}

InferencerImpl(shared_ptr<Graph const> paino_graph)
    : BaseInferencerImpl<T>(paino_graph) {}

typename InferencerImpl<T>::Builder *GetBuilder() {
    return new Builder();
}

~InferencerImpl() {
    delete clean_up_head_;
    delete initialization_head_;
    delete inference_visitor_;
}

std::vector<T> GetTensorCPUData(Node *node) {
    return node_ptr_to_tensor_cpu_vec_.at(node);
}

void FillInputs(std::unordered_map<std::string, std::vector<T>> const &preprocess_input) {
    for (auto graph_iterator = BaseInferencerImpl<T>::GetImmutableGraph()->begin();
         graph_iterator != BaseInferencerImpl<T>::GetImmutableGraph()->end();
         ++graph_iterator) {
        if (preprocess_input.count(graph_iterator->name())) {
            node_ptr_to_tensor_cpu_vec_.at(*graph_iterator) = preprocess_input.at(graph_iterator->name());
        } else {
            using std::fill;
            fill(node_ptr_to_tensor_cpu_vec_.at(*graph_iterator).begin(),
                node_ptr_to_tensor_cpu_vec_.at(*graph_iterator).end(),
                0);
        }
    }
}

AbstractHandler *GetInitializeHeader() {
    return initialization_head_;
}
end note

class Builder {
  + GetBaseInferencerImplPtr() : BaseInferencerImpl<T> *
}
InferencerImpl +-- Builder
dynasty::inferencer::common::BaseInferencerImpl <|-- InferencerImpl
dynasty::inferencer::common::Builder <|-- Builder

note left of Builder

BaseInferencerImpl<T>* GetBaseInferencerImplPtr() {
  return new InferencerImpl<T>(BaseInferencerImpl<T>::Builder::GetGraph());
}


end note

class SetCPUTensorVector {
  + handle() : void
}

dynasty::inferencer::common::BaseHandler <|-- SetCPUTensorVector


class Inferencer {
  + {static} GetBuilder() : unique_ptr<PianoInferencer<T>::Builder>
}

note right of Inferencer
  unique_ptr<PianoInferencer<T>::Builder> Inferencer<T>::GetBuilder() {
    return unique_ptr<PianoInferencer<T>::Builder>(InferencerImpl<T>::GetBuilder());
  }

end note

dynasty::inferencer::PianoInferencer <|-- Inferencer

} /'namespace cpu'/


}
}
@enduml