#include <node_impl.hpp>

Inheritance diagram for node_impl:

Public Member Functions
	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 Public Member Functions
static std::shared_ptr< node_impl >	read_node (std::istream &stream)

Private Member Functions
	node_impl (node_impl const &n)
	not implemented More...

node_impl &	operator= (node_impl const &n)
	not implemented More...

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

Detailed Description

Base class for all parse tree nodes. The node classes all derive from node_impl. Each derived class overrides print_node(), for debugging and evalute_node() to evaluate the node. A few classes also override evaluate_string(), but most classes can inherit the node_impl::evaluate_string implementation, which prints the result of calling evaluate().

This class primarily manages the reference count.

Definition at line 20 of file node_impl.hpp.

Constructor & Destructor Documentation

node_impl::node_impl ( )

Definition at line 12 of file node_impl.cpp.

13 {}

node_impl::~node_impl ( )

virtual

Definition at line 15 of file node_impl.cpp.

16 {}

node_impl::node_impl ( node_impl const & n )

private

not implemented

Member Function Documentation

double node_impl::evaluate ( ) const

Definition at line 24 of file node_impl.cpp.

References evaluate_node().

Referenced by evaluate_string().

 {
   return evaluate_node();
 }

virtual double node_impl::evaluate_node ( ) const

privatepure virtual

Implemented in node_divide, node_multiply, node_subtract, node_add, node_negate, node_binary, node_unary, node_function_call, node_function, node_identifier, node_number, and node_void.

Referenced by evaluate().

identifier_list const & node_impl::evaluate_parameters ( ) const

privatevirtual

Reimplemented in node_function.

Definition at line 50 of file node_impl.cpp.

Referenced by get_parameters().

 {
   static identifier_list const empty{};
   return empty;
 }

std::string node_impl::evaluate_string ( ) const

privatevirtual

Reimplemented in node_identifier, and node_void.

Definition at line 42 of file node_impl.cpp.

References evaluate().

Referenced by to_string().

 {
   std::ostringstream stream{};
   stream << evaluate();
   return stream.str();
 }

identifier_list const & node_impl::get_parameters ( ) const

Definition at line 36 of file node_impl.cpp.

References evaluate_parameters().

 {
   return evaluate_parameters();
 }

node_impl& node_impl::operator= ( node_impl const & n )

private

not implemented

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

Definition at line 18 of file node_impl.cpp.

References print_node().

 {
   print_node(stream, indent);
 }

virtual void node_impl::print_node	(	std::ostream &	stream,
		int	indent
	)		const

privatepure virtual

Implemented in node_divide, node_multiply, node_subtract, node_add, node_negate, node_binary, node_unary, node_function_call, node_function, node_identifier, node_number, and node_void.

Referenced by print().

std::shared_ptr< node_impl > node_impl::read_node ( std::istream & stream )

static

Read the node type from a library file, then create the proper kind of node.

Definition at line 64 of file node_impl.cpp.

Referenced by node::node().

 {
   std::string type{};
   if (not (stream >> type))
     return nullptr;
   if (type == "void")
     return std::make_shared<node_void>(stream);
   if (type == "number")
     return std::make_shared<node_number>(stream);
   if (type == "identifier")
     return std::make_shared<node_identifier>(stream);
   if (type == "function")
     return std::make_shared<node_function>(stream);
   if (type == "call")
     return std::make_shared<node_function_call>(stream);
   if (type == "negate")
     return std::make_shared<node_negate>(stream);
   if (type == "add")
     return std::make_shared<node_add>(stream);
   if (type == "subtract")
     return std::make_shared<node_subtract>(stream);
   if (type == "multiply")
     return std::make_shared<node_multiply>(stream);
   if (type == "divide")
     return std::make_shared<node_divide>(stream);
 
   throw calc_error{"unknown node type: " + type};
 }