pzks-labs/inc/expression.hpp

#pragma once

#include <iostream>
#include <sstream>
#include <memory>
#include <string>

namespace Expression {

class Token {
public:
	enum TokenType {
		VAR,
		CONST,
		OPERATOR,
		CV, // compound value (result of an operation)
		NAT, // not a token
	} t;

	enum Operator {
		OPA, // opening parentheses
		CPA, // closing parentheses
		ADD,
		SUB,
		MUL,
		DIV,
		POW
	};

	union TokenValue {
		std::shared_ptr<std::string> s;
		double d;
		Operator o;
		struct {
			int w; // weight
			int i; // index in operation vector
		} cv;

		explicit TokenValue(std::string& s)
			: s(std::make_shared<std::string>(s))
		{
		}

		explicit TokenValue(double d)
			: d(d)
		{
		}

		explicit TokenValue(enum Operator o)
			: o(o)
		{
		}

		explicit TokenValue(void)
		{
		}

		~TokenValue(void)
		{
		}
	} v;

	Token(void)
	{

	}

	Token(std::string s)
		: v(s)
	{
		t = VAR;
	}

	Token(double d)
		: v(d)
	{
		t = CONST;
	}

	Token(enum Operator o)
		: v(o)
	{
		t = OPERATOR;
	}

	Token(const Expression::Token& other)
	{
		t = other.t;

		switch (t)
		{
		case VAR:
			v.s = other.v.s;
			break;
		case CONST:
			v.d = other.v.d;
			break;
		case OPERATOR:
			v.o = other.v.o;
			break;
		case CV:
			v.cv.w = other.v.cv.w;
			v.cv.i = other.v.cv.i;
			break;
		case NAT:
			break;
		default:
			std::cout << "Warning: token type is invalid\n";
			break;
		}
	}

	Token(Expression::Token&& other)
	{
		t = other.t;

		switch (t)
		{
		case VAR:
			v.s = other.v.s;
			break;
		case CONST:
			v.d = other.v.d;
			break;
		case OPERATOR:
			v.o = other.v.o;
			break;
		case CV:
			v.cv.w = other.v.cv.w;
			v.cv.i = other.v.cv.i;
			break;
		case NAT:
			break;
		default:
			std::cout << "Warning: token type is invalid\n";
			break;
		}
	}

	Expression::Token& operator=(const Expression::Token& other)
	{
		t = other.t;

		switch (t)
		{
		case VAR:
			v.s = other.v.s;
			break;
		case CONST:
			v.d = other.v.d;
			break;
		case OPERATOR:
			v.o = other.v.o;
			break;
		case CV:
			v.cv.w = other.v.cv.w;
			v.cv.i = other.v.cv.i;
			break;
		case NAT:
			break;
		default:
			std::cout << "Warning: token type is invalid\n";
			break;
		}

		return const_cast<Expression::Token&>(other);
	}

	std::shared_ptr<std::string> to_str(void) const
	{
		switch (t)
		{
		case VAR:
			return v.s;
		case CONST:
		{
			char buffer[128] = {0};
			return std::make_shared<std::string>((std::ostringstream() << v.d).str());
		}
		case OPERATOR:
			return std::make_shared<std::string>("OP " + std::string(op_str()));
		default:
			return std::make_shared<std::string>("Not a valid token!");
		}
	}

	std::shared_ptr<std::string> to_math_str(void) const
	{
		switch (t)
		{
		case VAR:
			return v.s;
		case CONST:
		{
			char buffer[128] = {0};
			return std::make_shared<std::string>((std::ostringstream() << v.d).str());
		}
		case OPERATOR:
			return std::make_shared<std::string>(op_math_str());
		default:
			return std::make_shared<std::string>("Not a valid token!");
		}
	}

	const char *type_str(void) const
	{
		switch (t)
		{
		case VAR:
			return "VAR";
		case CONST:
			return "CONST";
		case OPERATOR:
			return "OPERATOR";
		default:
			return "Not a valid type";
		}
	}

	const char *op_str(void) const
	{
		if (t != OPERATOR)
		{
			return "Token is not an operator!";
		}

		switch (v.o)
		{
		case OPA:
			return "OPA";
		case CPA:
			return "CPA";
		case ADD:
			return "ADD";
		case SUB:
			return "SUB";
		case MUL:
			return "MUL";
		case DIV:
			return "DIV";
		case POW:
			return "POW";
		default:
			return "Invalid operator";
		}
	}

	const char *op_math_str(void) const
	{
		if (t != OPERATOR)
		{
			return "Token is not an operator!";
		}

		switch (v.o)
		{
		case OPA:
			return "(";
		case CPA:
			return ")";
		case ADD:
			return "+";
		case SUB:
			return "-";
		case MUL:
			return "*";
		case DIV:
			return "/";
		case POW:
			return "^";
		default:
			return "Invalid operator";
		}
	}
};

struct Operation
{
	Token o; // operator

	enum Type
	{
		NORMAL,
		DERIVED,
	} tl, tr; // type left, type right

	int il, ir; // index left, index right
	int w; // operation weight

	Operation(enum Expression::Token::Operator o, enum Type tl, int il, enum Type tr, int ir, int w)
		: o(o), tl(tl), tr(tr), il(il), ir(ir), w(w)
	{

	}
};

class TreeNode {
public:
	TreeNode *l; // left hand
	TreeNode *r; // right hand
	Token o; // if operator, left and right hands are valid
		 // if value, left and right hands should be null

	explicit TreeNode(void)
	{
	}

	explicit TreeNode(const Token t)
		: o(t)
	{
	}

	~TreeNode()
	{
		if (l != nullptr)
		{
			delete l;
		}

		if (r != nullptr)
		{
			delete r;
		}
	}
};

}