void field_op::parse_field_op(const XMLElement &field_op_element,
arena_allocator &alloc) {
typedef std::map<std::string, operator_enum_t> operator_map_t;
static const operator_map_t operator_map = map_list_of("none", operator_none)(
"constant", operator_constant)("delta", operator_delta)(
"default", operator_default)("copy", operator_copy)(
"increment", operator_increment)("tail", operator_tail);
auto itr = operator_map.find(field_op_element.Name());
if (itr == operator_map.end()) {
BOOST_THROW_EXCEPTION(
fast_static_error("S1") << reason_info(
std::string("Invalid field operator ") + field_op_element.Name()));
}
op_ = itr->second;
const char *opContext_key = get_optional_attr(
field_op_element, "key", context_ ? context_->key_ : nullptr);
const char *opContext_dict =
get_optional_attr(field_op_element, "dictionary",
context_ ? context_->dictionary_ : nullptr);
const char *opContext_ns = get_optional_attr(
field_op_element, "ns", context_ ? context_->ns_ : nullptr);
if (opContext_key || opContext_dict || opContext_ns) {
auto new_context = new (alloc) op_context_t;
new_context->key_ = string_dup(opContext_key, alloc);
new_context->ns_ = string_dup(opContext_ns, alloc);
new_context->dictionary_ = string_dup(opContext_dict, alloc);
context_ = new_context;
}
}
void ResponseCurve::setType(ResponseCurveType type)
{
typedef void (*ResponseCurveCalculator)(ResponseContainer&);
typedef map<ResponseCurveType, ResponseCurveCalculator> ResponseCurveFunc;
static ResponseCurveFunc funcs =
map_list_of
(RESPONSE_LOG10, &fillResponseLog10)
(RESPONSE_LINEAR, &fillResponseLinear)
(RESPONSE_GAMMA, &fillResponseGamma)
(RESPONSE_SRGB, &fillResponseSRGB)
;
ResponseCurveType type_ = RESPONSE_LINEAR;
ResponseCurveCalculator func_ = &fillResponseLinear;
ResponseCurveFunc::const_iterator it = funcs.find(type);
if (it != funcs.end())
{
type_ = it->first;
func_ = it->second;
}
m_type = type_;
func_(m_responses[RESPONSE_CHANNEL_RED]);
func_(m_responses[RESPONSE_CHANNEL_GREEN]);
func_(m_responses[RESPONSE_CHANNEL_BLUE]);
}
namespace mgraph
{
const string ELE::_convertele2str[107] = {"LP", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
"Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe",
"Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr", "Nb",
"Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba",
"La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
"Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn",
"Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md",
"No", "Lr", "Rf", "DU", "*"};
const map<string, ELE::_ELE> ELE::_convertstr2ele = map_list_of
("LP", ELE::LP) ("H", ELE::H) ("He", ELE::He) ("Li", ELE::Li) ("Be", ELE::Be)
("B", ELE::B) ("C", ELE::C) ("N", ELE::N) ("O", ELE::O) ("F", ELE::F)
("Ne", ELE::Ne) ("Na", ELE::Na) ("Mg", ELE::Mg) ("Al", ELE::Al) ("Si", ELE::Si)
("P", ELE::P) ("S", ELE::S) ("Cl", ELE::Cl) ("Ar", ELE::Ar) ("K", ELE::K)
("Ca", ELE::Ca) ("Sc", ELE::Sc) ("Ti", ELE::Ti) ("V", ELE::V) ("Cr", ELE::Cr)
("Mn", ELE::Mn) ("Fe", ELE::Fe) ("Co", ELE::Co) ("Ni", ELE::Ni) ("Cu", ELE::Cu)
("Zn", ELE::Zn) ("Ga", ELE::Ga) ("Ge", ELE::Ge) ("As", ELE::As) ("Se", ELE::Se)
("Br", ELE::Br) ("Kr", ELE::Kr) ("Rb", ELE::Rb) ("Sr", ELE::Sr) ("Y", ELE::Y)
("Zr", ELE::Zr) ("Nb", ELE::Nb) ("Mo", ELE::Mo) ("Tc", ELE::Tc) ("Ru", ELE::Ru)
("Rh", ELE::Rh) ("Pd", ELE::Pd) ("Ag", ELE::Ag) ("Cd", ELE::Cd) ("In", ELE::In)
("Sn", ELE::Sn) ("Sb", ELE::Sb) ("Te", ELE::Te) ("I", ELE::I) ("Xe", ELE::Xe)
("Cs", ELE::Cs) ("Ba", ELE::Ba) ("La", ELE::La) ("Ce", ELE::Ce) ("Pr", ELE::Pr)
("Nd", ELE::Nd) ("Pm", ELE::Pm) ("Sm", ELE::Sm) ("Eu", ELE::Eu) ("Gd", ELE::Gd)
("Tb", ELE::Tb) ("Dy", ELE::Dy) ("Ho", ELE::Ho) ("Er", ELE::Er) ("Tm", ELE::Tm)
("Yb", ELE::Yb) ("Lu", ELE::Lu) ("Hf", ELE::Hf) ("Ta", ELE::Ta) ("W", ELE::W)
("Re", ELE::Re) ("Os", ELE::Os) ("Ir", ELE::Ir) ("Pt", ELE::Pt) ("Au", ELE::Au)
("Hg", ELE::Hg) ("Tl", ELE::Tl) ("Pb", ELE::Pb) ("Bi", ELE::Bi) ("Po", ELE::Po)
("At", ELE::At) ("Rn", ELE::Rn) ("Fr", ELE::Fr) ("Ra", ELE::Ra) ("Ac", ELE::Ac)
("Th", ELE::Th) ("Pa", ELE::Pa) ("U", ELE::U) ("Np", ELE::Np) ("Pu", ELE::Pu)
("Am", ELE::Am) ("Cm", ELE::Cm) ("Bk", ELE::Bk) ("Cf", ELE::Cf) ("Es", ELE::Es)
("Fm", ELE::Fm) ("Md", ELE::Md) ("No", ELE::No) ("Lr", ELE::Lr) ("Rf", ELE::Rf)
("DU", ELE::DU) ("*", ELE::Any);
const string GEO::_convertg2str[7] = {"none", "lin", "tri", "tet", "bip", "oct", "UNK"};
const map<string, GEO::_GEO> GEO::_convertstr2g = map_list_of
("none", GEO::none) ("lin", GEO::lin)
("tri", GEO::tri) ("tet", GEO::tet)
("bip", GEO::bip) ("oct", GEO::oct)
("UNK", GEO::UNK);
}
namespace mgraph
{
const string BT::_convertbt2str[6] = {"s", "re", "ar", "d", "t", "UNK"};
const map<string, BT::_BT> BT::_convertstr2bt = map_list_of
("1", BT::s) ("s", BT::s)
("re", BT::re)
("ar", BT::ar)
("2", BT::d) ("d", BT::d)
("3", BT::t) ("t", BT::t)
("UNK", BT::UNK);
}
FusionOperator IFusionOperator::fromString(const std::string& type)
{
typedef map<string, FusionOperator, pfs::utils::StringUnsensitiveComp> Dict;
static Dict v =
map_list_of
("debevec", DEBEVEC)
("robertson", ROBERTSON)
("robertson-auto", ROBERTSON_AUTO)
;
Dict::const_iterator it = v.find(type);
if (it != v.end())
{
return it->second;
}
return DEBEVEC;
}
ResponseCurveType ResponseCurve::fromString(const std::string& type)
{
typedef map<string, ResponseCurveType, pfs::utils::StringUnsensitiveComp> Dict;
static Dict v =
map_list_of
("log10", RESPONSE_LOG10)
("log", RESPONSE_LOG10)
("linear", RESPONSE_LINEAR)
("gamma", RESPONSE_GAMMA)
("srgb", RESPONSE_SRGB)
;
Dict::const_iterator it = v.find(type);
if ( it != v.end() )
{
return it->second;
}
return RESPONSE_LINEAR;
}
namespace chess_engine
{
/*! name of chess colors */
static const map<int, string> NameColors = map_list_of
(NoColor, "nocolor")
(White, "white")
(Black, "black")
;
/*! name of chess pieces */
static const map<int, string> NamePieces = map_list_of
(NoPiece, "nopiece")
(King, "King")
(Queen, "Queen")
(Rook, "Rook")
(Bishop, "Bishop")
(Knight, "Knight")
(Pawn, "Pawn")
(UndefPiece, "undefined")
;
/*! unicode of white chess figurines */
static const map<int, string> FigurineWhitePieces = map_list_of
(NoPiece, " ")
(King, "\U00002654")
(Queen, "\U00002655")
(Rook, "\U00002656")
(Bishop, "\U00002657")
(Knight, "\U00002658")
(Pawn, "\U00002659")
(UndefPiece, "\U0000003F")
;
/*! unicode of black chess figurines */
static const map<int, string> FigurineBlackPieces = map_list_of
(NoPiece, " ")
(King, "\U0000265A")
(Queen, "\U0000265B")
(Rook, "\U0000265C")
(Bishop, "\U0000265D")
(Knight, "\U0000265E")
(Pawn, "\U0000265F")
(UndefPiece, "\U0000003F")
;
/*! name of chess castle moves */
static const map<int, string> NameCastling = map_list_of
(NoCastling, "nocastling")
(KingSide, "kingside")
(QueenSide, "queenside")
;
/*! name of chess action results */
static const map<int, string> NameResults = map_list_of
(NoResult, "noresult")
(Ok, "ok")
(BadMove, "badmove")
(OutOfTurn, "outofturn")
(Busy, "busy")
(InPlay, "inplay")
(Checkmate, "checkmate")
(Draw, "draw")
(Resign, "resign")
(Disqualified, "disqualified")
(NoGame, "nogame")
(GameFatal, "gamefatal")
;
/*! name of chess check modifiers */
static const std::map<int, std::string> NameCheckMod = map_list_of
(NoCheckMod, "nocheck")
(ModCheck, "check")
(ModDoubleCheck, "doublecheck")
(ModCheckmate, "checkmate")
;
/*! name of chess algebras */
static const std::map<int, std::string> NameAlgebra = map_list_of
(UnknownAN, "unknown")
(CAN, "Coordinate Algebra Notation")
(SAN, "Standard Algebra Notation")
;
// name map iterator type
typedef std::map<int, std::string>::const_iterator name_iter;
const string nameOfColor(ChessColor color)
{
name_iter iter = NameColors.find(color);
return iter != NameColors.end()? iter->second: NameColors.at(NoColor);
}
const string nameOfPiece(ChessPiece piece)
{
name_iter iter = NamePieces.find(piece);
return iter != NamePieces.end()? iter->second: NamePieces.at(NoPiece);
}
const string figurineOfPiece(ChessColor color, ChessPiece piece)
{
static const string strUnknown = "\U00002047"; // "??"
name_iter iter;
switch( color )
{
case White:
iter = FigurineWhitePieces.find(piece);
return iter != FigurineWhitePieces.end()? iter->second: strUnknown;
case Black:
iter = FigurineBlackPieces.find(piece);
return iter != FigurineBlackPieces.end()? iter->second: strUnknown;
default:
return strUnknown;
}
}
const string nameOfCastling(ChessCastling side)
{
name_iter iter = NameCastling.find(side);
return iter != NameCastling.end()? iter->second:
NameCastling.at(NoCastling);
}
const string nameOfResult(ChessResult result)
{
name_iter iter = NameResults.find(result);
return iter != NameResults.end()? iter->second: NameResults.at(NoResult);
}
const string nameOfCheckMod(ChessCheckMod checkmod)
{
name_iter iter = NameCheckMod.find(checkmod);
return iter != NameCheckMod.end()? iter->second:
NameCheckMod.at(NoCheckMod);
}
const string nameOfAlgebra(ChessAlgebra algebra)
{
name_iter iter = NameAlgebra.find(algebra);
return iter != NameAlgebra.end()? iter->second: NameAlgebra.at(UnknownAN);
}
ChessResult rcToMoveResult(int rc)
{
if( rc < 0 )
{
rc = -rc;
}
switch( rc )
{
case CE_OK: // good move
return Ok;
case CE_ECODE_CHESS_BAD_MOVE: // invalid move
case CE_ECODE_CHESS_PARSE:
return BadMove;
case CE_ECODE_CHESS_OUT_OF_TURN: // player out of turn
return OutOfTurn;
case CE_ECODE_BUSY: // move already in progress
return Busy;
case CE_ECODE_CHESS_NO_GAME: // no game in progress
return NoGame;
case CE_ECODE_NO_EXEC:
case CE_ECODE_TIMEDOUT:
case CE_ECODE_INTR:
return NoResult;
default: // fatal game errors
return GameFatal;
}
}
} // namespace chess_engine
typedef map<
pair<unsigned int,unsigned int>
,function<set<Code> (auto_ptr<OperatorSpace>,bool)>
> gatherCodesImplsType;
static const gatherCodesImplsType gatherCodesImpls = map_list_of
(make_pair(1u,1u),gatherCodesImpl<1,1>)
(make_pair(1u,2u),gatherCodesImpl<1,2>)
(make_pair(1u,3u),gatherCodesImpl<1,3>)
(make_pair(1u,4u),gatherCodesImpl<1,4>)
(make_pair(1u,5u),gatherCodesImpl<1,5>)
(make_pair(2u,1u),gatherCodesImpl<2,1>)
(make_pair(2u,2u),gatherCodesImpl<2,2>)
(make_pair(2u,3u),gatherCodesImpl<2,3>)
(make_pair(2u,4u),gatherCodesImpl<2,4>)
(make_pair(2u,5u),gatherCodesImpl<2,5>)
(make_pair(3u,1u),gatherCodesImpl<3,1>)
(make_pair(3u,2u),gatherCodesImpl<3,2>)
(make_pair(3u,3u),gatherCodesImpl<3,3>)
(make_pair(3u,4u),gatherCodesImpl<3,4>)
(make_pair(4u,1u),gatherCodesImpl<4,1>)
(make_pair(4u,2u),gatherCodesImpl<4,2>)
(make_pair(4u,3u),gatherCodesImpl<4,3>)
(make_pair(5u,1u),gatherCodesImpl<5,1>)
(make_pair(5u,2u),gatherCodesImpl<5,2>)
(make_pair(6u,1u),gatherCodesImpl<6,1>);
set<Code> gatherCodes(
auto_ptr<OperatorSpace> initial_space
, const bool ignore_solutions_with_trivial_columns
) {
