Skip to content
Snippets Groups Projects
Commit f0a461c1 authored by Adam Wardyński's avatar Adam Wardyński
Browse files

Helper formatters for string representation of unary and binary functions

parent 9582c976
No related branches found
No related tags found
No related merge requests found
...@@ -17,9 +17,10 @@ SET(libwccl_STAT_SRC ...@@ -17,9 +17,10 @@ SET(libwccl_STAT_SRC
exception.cpp exception.cpp
main.cpp main.cpp
ops/and.cpp ops/and.cpp
ops/or.cpp ops/formatters.cpp
ops/logicalpredicate.cpp ops/logicalpredicate.cpp
ops/nor.cpp ops/nor.cpp
ops/or.cpp
ops/predicate.cpp ops/predicate.cpp
sentencecontext.cpp sentencecontext.cpp
values/bool.cpp values/bool.cpp
......
#include <libwccl/ops/formatters.h>
namespace Wccl {
// ------ UnaryFunctionFormatter -----
std::string UnaryFunctionFormatter::to_raw_string(
const FunctionBase& f,
const FunctionBase& arg_expr,
const char* open_bracket,
const char* close_bracket)
{
std::string s(f.raw_operator_name());
s.append(open_bracket);
s.append(arg_expr.to_raw_string());
s.append(close_bracket);
return s;
}
std::string UnaryFunctionFormatter::to_string(
const Corpus2::Tagset& tagset,
const FunctionBase& f,
const FunctionBase& arg_expr,
const char* open_bracket,
const char* close_bracket)
{
std::string s(f.operator_name(tagset));
s.append(open_bracket);
s.append(arg_expr.to_string(tagset));
s.append(close_bracket);
return s;
}
// ----- BinaryFunctionFormatter ------
std::string BinaryFunctionFormatter::to_string(
const Corpus2::Tagset& tagset,
const FunctionBase& f,
const FunctionBase& arg1_expr,
const FunctionBase& arg2_expr)
{
std::string s(f.operator_name(tagset));
s.append("(");
s.append(arg1_expr.to_string(tagset));
s.append(", ");
s.append(arg2_expr.to_string(tagset));
s.append(")");
return s;
}
std::string BinaryFunctionFormatter::to_raw_string(
const FunctionBase& f,
const FunctionBase& arg1_expr,
const FunctionBase& arg2_expr)
{
std::string s(f.raw_operator_name());
s.append("(");
s.append(arg1_expr.to_raw_string());
s.append(", ");
s.append(arg2_expr.to_raw_string());
s.append(")");
return s;
}
} /* end ns Wccl */
#ifndef FORMATTERS_H
#define FORMATTERS_H
#include <boost/shared_ptr.hpp>
#include <libcorpus2/tagset.h>
#include <libwccl/ops/functions.h>
namespace Wccl {
/**
* Class that formats unary functions as string
*/
struct UnaryFunctionFormatter
{
/**
* String representation of an unary function.
* It is in form of
* operator_name(argument_expression_string)
* although the open and close brackets can be changed
* (some operators use [])
*/
static std::string to_string(
const Corpus2::Tagset& tagset,
const FunctionBase& f,
const FunctionBase& arg_expr,
const char* open_bracket = "(",
const char* close_bracket = ")");
/**
* Raw string representation of an unary function.
* Does not require tagset, may contain internal info
* and/or be incomplete. It is in form of
* raw_operator_name(raw_argument_expression_string)
* although the open and close brackets can be changed
* (some operators use [])
*/
static std::string to_raw_string(
const FunctionBase& f,
const FunctionBase& arg_expr,
const char* open_bracket = "(",
const char* close_bracket = ")");
};
/**
* Class that formats binary functions as string
*/
struct BinaryFunctionFormatter
{
/**
* String representation of a binary function.
* It is in form of
* operator_name(arg1_expr_string, arg2_expr_string)
*/
static std::string to_string(
const Corpus2::Tagset& tagset,
const FunctionBase& f,
const FunctionBase& arg1_expr,
const FunctionBase& arg2_expr);
/**
* Raw string representation of a binary function.
* Does not require tagset, may contain internal info
* and/or be incomplete. It is in form of
* raw_op_name(raw_arg1_expr_string, raw_arg2_expr_string)
*/
static std::string to_raw_string(
const FunctionBase& f,
const FunctionBase& arg1_expr,
const FunctionBase& arg2_expr);
};
} /* end ns Wccl */
#endif // FORMATTERS_H
...@@ -51,133 +51,6 @@ public: ...@@ -51,133 +51,6 @@ public:
} }
}; };
/**
* Abstract base class template for functional WCCL operators returning
* a value of given type, while taking a single argument of selected type.
* The argument is actually realised as a functional expression that returns
* value of the specified type, per the unary function requirements.
*/
template<class TArg, class TRet>
class UnaryFunction : public Function<TRet> {
public:
/**
* Shared pointer type of expression that returns argument for
* our unary function application
*/
typedef boost::shared_ptr<Function<TArg> > ArgExprPtr;
UnaryFunction(const ArgExprPtr& arg_expr)
: arg_expr_(arg_expr)
{
BOOST_ASSERT(arg_expr_);
}
/**
* String representation of the unary function, realised by default
* as "operator_name(argument_string)" (using open and close
* brackets supplied by open_bracket() and close_bracket())
*/
virtual std::string to_string(const Corpus2::Tagset& tagset) const {
std::string returnValue(this->operator_name(tagset));
returnValue.append(open_bracket());
returnValue.append(arg_expr_->to_string(tagset));
returnValue.append(close_bracket());
return returnValue;
}
/**
* String representation of the unary function, that does not
* require tagset. May be incomplete and/or contain internal info.
* Realised by default as "raw_operator_name(raw_argument_string)"
* (using open and close brackets supplied by open_bracket()
* and close_bracket())
*/
virtual std::string to_raw_string() const {
std::string returnValue(this->raw_operator_name());
returnValue.append(open_bracket());
returnValue.append(arg_expr_->to_raw_string());
returnValue.append(close_bracket());
return returnValue;
}
protected:
const ArgExprPtr arg_expr_;
/**
* Opening bracket to use in string representation.
* By default it is "(", but some operators use "["
*/
virtual const char* open_bracket() {
return "(";
}
/**
* Closing bracket to use in string representation.
* By default it is ")", but some operators use "]"
*/
virtual const char* close_bracket() {
return ")";
}
};
/**
* Abstract base class template for functional WCCL operators returning
* a value of given type, while taking two arguments of selected types.
* The arguments are actually realised as functions that return
* value of a specified type, per the binary function requirements.
*/
template<class TArg1, class TArg2, class TRet>
class BinaryFunction : public Function<TRet> {
public:
/**
* Shared pointer type of expression that returns first argument for
* our binary function application
*/
typedef boost::shared_ptr<Function<TArg1> > Arg1ExprPtr;
/**
* Shared pointer type of expression that returns second argument for
* our binary function application
*/
typedef boost::shared_ptr<Function<TArg2> > Arg2ExprPtr;
BinaryFunction(const Arg1ExprPtr& arg1_expr, const Arg2ExprPtr& arg2_expr)
: arg1_expr_(arg1_expr), arg2_expr_(arg2_expr)
{
BOOST_ASSERT(arg1_expr_);
BOOST_ASSERT(arg2_expr_);
}
/**
* String representation of the binary function, realised by default
* as "operator_name(arg1_string, arg2_string)"
*/
virtual std::string to_string(const Corpus2::Tagset& tagset) const {
std::string returnValue(this->operator_name(tagset));
returnValue.append("(");
returnValue.append(arg1_expr_->to_string(tagset));
returnValue.append(", ");
returnValue.append(arg2_expr_->to_string(tagset));
returnValue.append(")");
return returnValue;
}
/**
* String representation of the binary function, that does not
* require tagset. May be incomplete and/or contain internal info.
* Realised by default as "raw_operator_name(raw_arg1_string, raw_arg2_string)"
*/
virtual std::string to_raw_string() const {
std::string returnValue(this->raw_operator_name());
returnValue.append("(");
returnValue.append(arg1_expr_->to_raw_string());
returnValue.append(", ");
returnValue.append(arg2_expr_->to_raw_string());
returnValue.append(")");
return returnValue;
}
protected:
const Arg1ExprPtr arg1_expr_;
const Arg2ExprPtr arg2_expr_;
};
} /* end ns Wccl */ } /* end ns Wccl */
#endif // FUNCTIONS_H #endif // FUNCTIONS_H
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment