PrefixRankedBarTree.cpp

/*
 * PrefixRankedBarTree.cpp
 *
 *  Created on: Nov 23, 2013
 *      Author: Jan Travnicek
 */

#include "PrefixRankedBarTree.h"
#include "../../exception/AlibException.h"

#include <sstream>
#include <algorithm>
#include <deque>

#include "RankedTree.h"

namespace tree {

PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : bar(std::move(bar)) {
	this->alphabet = std::move(alphabet);
	setContent(std::move(data));
}

PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, std::vector<alphabet::RankedSymbol> data) : bar(std::move(bar)) {
	arityChecksum(data);

	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
	m_Data = std::move(data);
}

PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, const RankedTree& tree) : bar(std::move(bar)) {
	toPrefixRankedBar(tree.getRoot());
	alphabet = std::set<alphabet::RankedSymbol>(m_Data.begin(), m_Data.end());
}

void PrefixRankedBarTree::toPrefixRankedBar(const RankedNode& node) {
	m_Data.push_back(node.getSymbol());
	for(const RankedNode* child : node.getChildren())
		toPrefixRankedBar(*child);
	m_Data.push_back(alphabet::RankedSymbol(bar, node.getSymbol().getRank()));
}

TreeBase* PrefixRankedBarTree::clone() const {
	return new PrefixRankedBarTree(*this);
}

TreeBase* PrefixRankedBarTree::plunder() && {
	return new PrefixRankedBarTree(std::move(*this));
}

bool PrefixRankedBarTree::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");

	return alphabet.erase(symbol);
}

const std::vector<alphabet::RankedSymbol>& PrefixRankedBarTree::getContent() const {
	return this->m_Data;
}

const alphabet::Symbol& PrefixRankedBarTree::getBarSymbol() const {
	return bar;
}

void PrefixRankedBarTree::setContent(std::vector<alphabet::RankedSymbol> data) {
	arityChecksum(data);

	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
	std::set<alphabet::RankedSymbol> unknownSymbols;
	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));

	if(unknownSymbols.size() > 0)
		throw exception::AlibException("Input symbols not in the alphabet.");

	this->m_Data = std::move(data);
}

void PrefixRankedBarTree::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
	int arityChecksumTerminals = 1;
	int arityChecksumBars = 1;
	int arityChecksumTypes = 0;
	for(const alphabet::RankedSymbol& symbol : data) {
		if(symbol.getSymbol() != bar) {
			arityChecksumTerminals += symbol.getRank().getData();
			arityChecksumTerminals -= 1;
			arityChecksumTypes += 1;
		} else {
			arityChecksumBars += symbol.getRank().getData();
			arityChecksumBars -= 1;
			arityChecksumTypes -= 1;
		}
	}

	if(arityChecksumTerminals != 0 || arityChecksumBars != 0 || arityChecksumTypes != 0) throw exception::AlibException("The string does not form a tree");
}

bool PrefixRankedBarTree::isEmpty() const {
	return this->m_Data.size() == 0;
}

int PrefixRankedBarTree::compare(const PrefixRankedBarTree& other) const {
	auto first = std::tie(m_Data, alphabet);
	auto second = std::tie(other.m_Data, other.alphabet);

	std::compare<decltype(first)> comp;
	return comp(first, second);
}

void PrefixRankedBarTree::operator >>(std::ostream& out) const {
	if( this->isEmpty() ) {
		out << "(Epsilon)";
	} else {
		out << "(PrefixRankedBarTree ";
		for(const alphabet::RankedSymbol& symbol : this->m_Data)
			out << symbol;
		out << ")";
	}
}

PrefixRankedBarTree::operator std::string () const {
	std::stringstream ss;
	if( this->isEmpty() ) {
		ss << "E";
	} else {
		ss << "\"";
		for(const alphabet::RankedSymbol& symbol : this->m_Data)
			ss << (std::string) symbol;
		ss << "\"";
	}
	return std::move(ss).str();
}

} /* namespace tree */