node_impl.hpp

Go to the documentation of this file.

#ifndef NODE_IMPL_HPP_
#define NODE_IMPL_HPP_

#include <cstdlib>
#include <memory>
#include <string>

#include "node.hpp"

class node_impl {
public:
  node_impl();
  virtual ~node_impl();

  void print(std::ostream& stream, int indent) const;

  double evaluate() const;

  std::string to_string() const;

  identifier_list const& get_parameters() const;

  void save(std::ostream& stream) const;

  static std::shared_ptr<node_impl> read_node(std::istream& stream);
private:
  node_impl(node_impl const& n); 
  node_impl& operator=(node_impl const& n); 

  virtual void print_node(std::ostream& stream, int indent) const = 0;
  virtual double evaluate_node() const = 0;
  virtual std::string evaluate_string() const;
  virtual identifier_list const& evaluate_parameters() const;
  virtual void save_node(std::ostream& stream) const = 0;
};

class node_void : public node_impl {
public:
  node_void();
  node_void(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual std::string evaluate_string() const override;
  virtual void save_node(std::ostream& stream) const override;
};

class node_number : public node_impl {
public:
  node_number(double value);
  node_number(std::istream& stream);
  double value() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;

  double value_;
};

class node_identifier : public node_impl {
public:
  node_identifier(std::string name);
  node_identifier(std::istream& stream);
  std::string const& name() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual std::string evaluate_string() const override;
  virtual void save_node(std::ostream& stream) const override;

  std::string name_;
};

class node_function : public node_impl {
public:
  node_function(identifier_list parameters, node definition);
  node_function(std::istream& stream);
  identifier_list const& parameters() const;
  node definition() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual identifier_list const& evaluate_parameters() const override;
  virtual void save_node(std::ostream& stream) const override;

  identifier_list parameters_;
  node definition_;
};

class node_function_call : public node_impl {
public:
  node_function_call(std::string name, node_list arguments);
  node_function_call(std::istream& stream);
  std::string name() const;
  node_list const& arguments() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;

  std::string name_;
  node_list arguments_;
};

class node_unary : public node_impl {
public:
  node_unary(node operand);
  node operand()  const;
protected:
  node_unary(std::istream& stream);
  double evaluate_operand() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override = 0;
  virtual double evaluate_node() const override = 0;
  virtual void save_node(std::ostream& stream) const override = 0;

  node operand_;
};

class node_binary : public node_impl {
public:
  node_binary(node left, node right);
  node left()  const;
  node right() const;
protected:
  node_binary(std::istream& stream);
  double evaluate_left() const;
  double evaluate_right() const;
private:
  virtual void print_node(std::ostream& stream, int indent) const override = 0;
  virtual double evaluate_node() const override = 0;
  virtual void save_node(std::ostream& stream) const override = 0;

  node left_;
  node right_;
};

class node_negate : public node_unary {
public:
  node_negate(node operand);
  node_negate(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;
};

class node_add : public node_binary {
public:
  node_add(node left, node right);
  node_add(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;
};

class node_subtract : public node_binary {
public:
  node_subtract(node left, node right);
  node_subtract(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;
};

class node_multiply : public node_binary {
public:
  node_multiply(node left, node right);
  node_multiply(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;
};

class node_divide : public node_binary {
public:
  node_divide(node left, node right);
  node_divide(std::istream& stream);
private:
  virtual void print_node(std::ostream& stream, int indent) const override;
  virtual double evaluate_node() const override;
  virtual void save_node(std::ostream& stream) const override;
};

#endif