/* ---- This file is part of SECONDO. Copyright (C) 2014, Faculty of Mathematics and Computer Science, Database Systems for New Applications. SECONDO is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. SECONDO is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with SECONDO; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ---- 1 TypeMapTestAlgebra This algebra is just for testing the implementation of the type mapper within the tools directory. It provides operators calling the functions of this mapper class. 1.1. includes and global variables */ #include "Algebra.h" #include "NestedList.h" #include "QueryProcessor.h" #include "Tools/TypeMap/Mapper.h" #include "StandardTypes.h" #include "Algebras/FText/FTextAlgebra.h" #include "ListUtils.h" extern NestedList* nl; extern QueryProcessor *qp; extern AlgebraManager *am; static NestedList* pnl; // Nested list storage for persistent //storing of nested lists static typemap::Mapper* mapper; // instance of the mapper class using namespace std; /* 2 Operators 2.1 Operator tminit 2.1.1 Type mapping */ ListExpr tminitTM(ListExpr args){ string err = "string or text expected"; if(!nl->HasLength(args,1)){ return listutils::typeError(err); } ListExpr a = nl->First(args); if(CcString::checkType(a) || FText::checkType(a)){ return listutils::basicSymbol(); } return listutils::typeError(err); } /* 2.1.2 Value Mapping */ void createMapper(){ pnl = new NestedList(); mapper = new typemap::Mapper(pnl,nl); } template int tminitVM1 (Word* args, Word& result, int message, Word& local, Supplier s ){ if(mapper==0){ createMapper(); } T* arg = (T*) args[0].addr; result = qp->ResultStorage(s); CcBool* res = (CcBool*) result.addr; if(!arg->IsDefined()){ res->SetDefined(false); return 0; } bool success = mapper->init(arg->GetValue()); res->Set(true, success); return 0; } /* 2.1.3 Value Mapping Array and Selection function */ ValueMapping tminitVM[] = { tminitVM1, tminitVM1 }; int tminitSelect(ListExpr args){ return CcString::checkType(nl->First(args))?0:1; } /* 2.1.4 Specification */ OperatorSpec tminitSpec( " {string, text} -> bool", " tminit(_)", " Calls the init function of the type mapper", "query tminit('../Algebras/tmspecs')" ); /* 2.1.5 Operator instance */ Operator tminitOP( "tminit", tminitSpec.getStr(), 2, tminitVM, tminitSelect, tminitTM ); /* 2.2 OPerator getOpSig 2.1.1 Type Map */ ListExpr getOpSigTM(ListExpr args){ string err = " {string, text} x string expected" ; if(!nl->HasLength(args,2)){ return listutils::typeError(err); } if((!CcString::checkType(nl->First(args)) && (!FText::checkType(nl->First(args)))) || !CcString::checkType(nl->Second(args))){ return listutils::typeError(err); } return listutils::basicSymbol(); } template int getOpSigVM1 (Word* args, Word& result, int message, Word& local, Supplier s ){ T* an = (T*) args[0].addr; CcString* on = (CcString*) args[1].addr; result = qp->ResultStorage(s); FText* res = (FText*) result.addr; if(!an->IsDefined() || !on->IsDefined()){ res->SetDefined(false); return 0; } if(mapper==0){ res->Set("getOpSig called without tminit"); return 0; } string v = pnl->ToString(mapper->getOpSig(an->GetValue(),on->GetValue())); res->Set(true,v); return 0; } /* 2.2.3 Value Mapping Array and Selection function */ ValueMapping getOpSigVM[] = { getOpSigVM1, getOpSigVM1 }; int getOpSigSelect(ListExpr args){ return CcString::checkType(nl->First(args))?0:1; } /* 2.2.4 Specification */ OperatorSpec getOpSigSpec( " {string, text} x string -> text", " tmgetOpSig(algname, opname)", " Calls the getOpSig function of the type mapper", "query tmgetOpSig('StandardAlgebra', \"+\")" ); /* 2.2.5 Operator instance */ Operator getOpSigOP( "tmgetOpSig", getOpSigSpec.getStr(), 2, getOpSigVM, getOpSigSelect, getOpSigTM ); /* 2.3 Operator TypeMap */ ListExpr tmtypemapTM(ListExpr args){ string err = "text x any x any x ... expected"; if(nl->ListLength(args)<1){ return listutils::typeError(err); } if(!FText::checkType(nl->First(args))){ string err = "text x any x any x ... expected"; } return nl->ThreeElemList( nl->SymbolAtom(Symbols::APPEND()), nl->OneElemList(nl->TextAtom(nl->ToString(nl->Rest(args)))), listutils::basicSymbol()); } int tmtypemapVM (Word* args, Word& result, int message, Word& local, Supplier s ){ FText* sigArgsType = (FText*) args[0].addr; result = qp->ResultStorage(s); FText* res = (FText*) result.addr; FText* currentArgs = (FText* ) args[qp->GetNoSons(s)-1].addr; ListExpr sat; ListExpr cat; if(!sigArgsType->IsDefined() || !currentArgs->IsDefined()){ res->SetDefined(false); return 0; } if(pnl==0 || mapper==0){ res->Set(true, "missing initialization, call tmpinit before"); return 0; } if(!pnl->ReadFromString(sigArgsType->GetValue(),sat) || !nl->ReadFromString(currentArgs->GetValue(),cat)){ res->Set(true, "Cannot parse list"); return 0; } if(!mapper){ res->Set(true, "mapper not initialized"); return 0; } res->Set(true, nl->ToString( mapper->typemap(sat,cat))); return 0; } OperatorSpec tmtypemapSpec( " text x any x any x ... -> text", " tmtypemap( sigargslist, current arguments)", " Calls the typemape function of the type mapper", "query tmgtypemap( tmgetOpSig('StandardAlgebra',\"+\", 3,4))" ); Operator tmtypemapOP ( "tmtypemap", //name tmtypemapSpec.getStr(), //specification tmtypemapVM, //value mapping Operator::SimpleSelect, //trivial selection function tmtypemapTM //type mapping ); class TypeMapTestAlgebra: public Algebra{ public: TypeMapTestAlgebra(): Algebra(){ // initialize global variables pnl = 0; mapper = 0; AddOperator(&tminitOP); AddOperator(&getOpSigOP); AddOperator(&tmtypemapOP); } ~TypeMapTestAlgebra(){ if(mapper){ delete mapper; mapper = 0; } if(pnl){ delete pnl; pnl = 0; } } }; extern "C" Algebra* InitializeTypeMapTestAlgebra( NestedList* nlRef, QueryProcessor* qpRef ) { nl = nlRef; qp = qpRef; return (new TypeMapTestAlgebra()); }