#include "StdAfx.h"
#include <GPUCVSwitch/macro.h>
#include <GPUCVSwitch/Cl_GenSw_Fct.h>
#include <iostream>
#include <fstream>
#include <string>
namespace GCV{
using namespace std;
using namespace GCV;
/**
Look for the given input string into the list of strings and return the string ID, -1 if not found
*/
int FindCheckPatternIntoStrings(std::string inputstr, std::string * _strList,
int _strNbr
)
{
size_t Start = 0;
bool Loop = true;
for(int i =0; i < _strNbr; i++)
{
Start = inputstr.find(_strList[i]);
if (Start!=std::string::npos)
return i;
}
return -1;
}
//==================================================
CL_FctAgrs::CL_FctAgrs(const std::string &_name)
: SGE::CL_XML_BASE_OBJ<std::string>(_name, "Arg")
,m_Const(false)
,m_ObjType(Obj_Unknown)
{
ParseArgument(_name);
ParseArgsType();
}
//==================================================
CL_FctAgrs::CL_FctAgrs(void)
: SGE::CL_XML_BASE_OBJ<std::string>("", "Arg")
,m_Const(false)
,m_ObjType(Obj_Unknown)
{
}
//==================================================
CL_FctAgrs::~CL_FctAgrs()
{
}
//==================================================
CL_FctAgrs& CL_FctAgrs::ParseArgument(const std::string &arg)
{
string LocalArgStr = arg;
size_t Start, Start_sp;//, Start_st, Start_am;
std::string subarg;
//check default value:
Start = LocalArgStr.find_first_of("=");
if(Start==std::string::npos)
{
Start = LocalArgStr.find("CV_DEFAULT");
}
if(Start!=std::string::npos)
{
m_DefaultVal = LocalArgStr.substr(Start, LocalArgStr.size());
LocalArgStr = LocalArgStr.substr(0, Start-1);
if(m_DefaultVal[m_DefaultVal.size()-1]!=')')
m_DefaultVal+=")";
}
//===============================
SGE::StrTrimLR(LocalArgStr);
SGE::StrTrimLastChar(LocalArgStr, ';');
SGE::StrTrimLastChar(LocalArgStr, ')');
SGE::StrTrimLR(LocalArgStr);
//check for type,
//it is normally every thing on the left of * or &
Start = LocalArgStr.find_last_of("*");
if(Start==std::string::npos)
{
Start = LocalArgStr.find_last_of("&");
}
if(Start!=std::string::npos)
{
m_Type = LocalArgStr.substr(0, Start+1);
m_Name = LocalArgStr.substr(Start+1, LocalArgStr.size());
}
else//we check for a space...
{
Start_sp = LocalArgStr.find_last_of(" ");
if(Start_sp!=std::string::npos)
{
m_Type = LocalArgStr.substr(0, Start_sp);
m_Name = LocalArgStr.substr(Start_sp+1, LocalArgStr.size());
}
}
//trim all space that might be there...
SGE::StrTrimLR(m_Type);
SGE::StrTrimLR(m_Name);
SGE::StrTrimLR(m_DefaultVal);
//check const values
Start = m_Type.find("const");
if(Start!=std::string::npos)
{
m_Const = true;
m_Type = m_Type.substr(Start+strlen("const"), m_Type.size());
}
else
m_Const = false;
//check that argument is not an array of type 'int x[4]'
Start =m_Name.find_first_of("[");
if(Start!=std::string::npos)
{
m_Name = m_Name.substr(0, Start);
m_Type += " * ";
}
if(m_Name=="" || m_Type=="")
{//just to make breakpoints
int a =0;
a++;
}
return *this;
}
//======================================================
std::string CL_FctAgrs::GenDefinition(ENUM_SrcFileType _fileType)
{
SG_Assert(GetName()!="", "Empty name");
std::string strDef;
if(GetObjType()==Obj_Param && GetConst()==true)
strDef += "const ";
strDef += GetType();
strDef += " ";
strDef += GetName();
if(_fileType==FILETYPE_H && GetDefaultVal()!="")
{
strDef += " ";
strDef += GetDefaultVal();
}
return strDef;
}
//======================================================
std::string StrngsTableSrc[] = {
"src"
,"mask"
//cvIntegral
,"image"
,"arr"
//cvFilter2D
,"kernel"
//cvgswReleasePyramid
,"pyramid"
};
std::string StrngsTableDst[] = {
"dst"
//cvIntegral
,"sum"
,"sqsum"
,"tilted_sum"
//cvWatershed
,"markers"
//cvgswCreatePyramid
//, "bufarr"??
};
std::string StrngsTableImage[] = {
"CvArr"
,"CvMat"
,"IplImage"
,"const CvArr*"
,"const CvArr *"
,"CvArr*"
,"CvArr *"
,"const CvMat*"
,"const CvMat *"
,"CvMat*"
,"CvMat *"
,"const IplImage*"
,"const IplImage *"
,"IplImage*"
,"IplImage *"
};
void CL_FctAgrs::ParseArgsType()
{
if (FindCheckPatternIntoStrings(GetType(), StrngsTableImage, sizeof(StrngsTableImage)/sizeof(std::string) ) !=-1)
{
/* if(GetType().find("**")!=std::string::npos)
{//when it is a pointer to pointer we do manage it ...
SetObjType(Obj_Mngd_GpuCV);
}
else
*/
if(GetConst()==true)//we assume const object are source object ;-)
{
SetObjType(Obj_Input_Arr);
}
else if (FindCheckPatternIntoStrings(GetName(), StrngsTableSrc, sizeof(StrngsTableSrc)/sizeof(std::string)) !=-1)
{
SetObjType(Obj_Input_Arr);
}
else if (FindCheckPatternIntoStrings(GetName(), StrngsTableDst, sizeof(StrngsTableDst)/sizeof(std::string)) !=-1)
{
SetObjType(Obj_Output_Arr);
}
else
{//unkown type...input output..?
SetObjType(Obj_UNKOWN_Arr);
}
//check mask
if(GetName().find("mask")!=std::string::npos)
{
SetObjType((ObjType)(GetObjType() | Obj_Mask_Arr));
}
}
else
{
SetObjType(Obj_Param);
}
}
//======================================================
TiXmlElement* CL_FctAgrs::XMLLoad(TiXmlElement* _XML_Root, const std::string & _subTagName)
{
SG_Assert(_XML_Root, "No XML root");
TiXmlElement* pLocalNode = SGE::XMLGetElement(_XML_Root, _subTagName);
if(pLocalNode)
{
//Load id
SGE::CL_XML_BASE_OBJ<std::string>::XMLLoad(pLocalNode);
//Load values
SGE::XMLReadVal(pLocalNode,"Const", m_Const);
SGE::XMLReadVal(pLocalNode,"Type", m_Type);
SGE::XMLReadVal(pLocalNode,"Name", m_Name);
SGE::XMLReadVal(pLocalNode,"DefaultVal", m_DefaultVal);
int iObjType = 0;
int currentVal=0;
m_ObjType=Obj_Unknown;
SGE::XMLReadVal(_XML_Root,"GpuMngd", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_Mngd_GpuCV;
currentVal=0;
SGE::XMLReadVal(_XML_Root,"SrcArr", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_Input_Arr;
currentVal=0;
SGE::XMLReadVal(_XML_Root,"DstArr", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_Output_Arr;
currentVal=0;
SGE::XMLReadVal(_XML_Root,"Mask", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_Mask_Arr;
currentVal=0;
SGE::XMLReadVal(_XML_Root,"Param", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_Param;
currentVal=0;
SGE::XMLReadVal(_XML_Root,"UNKOWN_TYPE", currentVal);
if(currentVal)
iObjType= (int)iObjType | (int)Obj_UNKOWN_Arr;
m_ObjType = (ObjType) iObjType;
}
return pLocalNode;
}
//======================================================
TiXmlElement* CL_FctAgrs::XMLSave(TiXmlElement* _XML_Root, const std::string & _subTagName)
{
SG_Assert(_XML_Root, "No XML root");
//save id
SGE::CL_XML_BASE_OBJ<std::string>::XMLSave(_XML_Root);
//save values
if(m_Const)
SGE::XMLWriteVal(_XML_Root,"Const", m_Const);
SGE::XMLWriteVal(_XML_Root,"Type", m_Type);
SGE::XMLWriteVal(_XML_Root,"Name", m_Name);
if(m_DefaultVal!="")
SGE::XMLWriteVal(_XML_Root,"DefaultVal",m_DefaultVal);
int currentVal=1;
if((m_ObjType & Obj_Mngd_GpuCV)==Obj_Mngd_GpuCV)
SGE::XMLWriteVal(_XML_Root,"GpuMngd", currentVal);
if((m_ObjType & Obj_Input_Arr)==Obj_Input_Arr)
SGE::XMLWriteVal(_XML_Root,"SrcArr", currentVal);
if((m_ObjType & Obj_Output_Arr)==Obj_Output_Arr)
SGE::XMLWriteVal(_XML_Root,"DstArr", currentVal);
if((m_ObjType & Obj_Mask_Arr)==Obj_Mask_Arr)
SGE::XMLWriteVal(_XML_Root,"Mask", currentVal);
if((m_ObjType & Obj_Param)==Obj_Param)
SGE::XMLWriteVal(_XML_Root,"Param", currentVal);
if((m_ObjType & Obj_UNKOWN_Arr)==Obj_UNKOWN_Arr)
SGE::XMLWriteVal(_XML_Root,"UNKOWN_TYPE", currentVal);
return _XML_Root;
}
//======================================================
//======================================================
//======================================================
CL_GenSwFn::CL_GenSwFn(const std::string &_name):
SGE::CL_XML_BASE_OBJ<std::string>(_name, "FctDef")
,m_Fntype("")
,m_FnName("")
,m_Argstr("")
,m_SwFnType("")
,m_Dst_Arr()
,m_Src_Arr()
,m_RequireSwitching(false)
//,m_Args_Type()
//,m_Args_Name()
//,m_Args_DefltVal()
{
};
bool CL_GenSwFn::MatchBrackets(std::string &currArg, size_t &StartBracketPos, size_t &StopBracketPos)
{
std::string TempStr=currArg;
size_t Start = 0;
size_t End = 0;
bool loop = true;
int StartBrkts = 0;
int EndBrkts = 0;
StartBracketPos = StopBracketPos = 0;
do
{
Start = TempStr.find_first_of("(");
if (Start!=std::string::npos)
{
if(Start>1)
{
//Start = TempStr.find_first_of("(");
//if (Start!=std::string::npos)
// break;
StartBracketPos = Start;
//StartBrkts++;
for(size_t i =Start; i < TempStr.size(); i++)
{
if(TempStr[i]==')')
EndBrkts++;
else if(TempStr[i]=='(')
StartBrkts++;
if(EndBrkts==StartBrkts)
{
StopBracketPos = i;
loop=false;
break;
}
}
//StartBrkts++;
}
else
TempStr = TempStr.substr(Start+1, TempStr.size()-Start-1);
/*End = TempStr.find_first_of(")");
if (End!=std::string::npos)
{
EndBrkts++;
}
else loop=false;
*/
}
else loop=false;
}
while (loop);
if(StartBracketPos!= StopBracketPos && StopBracketPos!=0)
return true;//>1 && StartBrkts==EndBrkts) return true;
else
return false;
}
//================================================
bool CL_GenSwFn::ParseLine(const std::string &line)
{
std::string args, currArg, subarg, func_name_args;
size_t Start = 0;
size_t End = 0;
size_t Start_sp = 0;
size_t Start_st = 0;
size_t Start_am = 0;
//read function type, name and args...
Start = line.find_first_of(" ");
if(Start==std::string::npos)
return false;
m_Fntype = line.substr(0, Start);
func_name_args = line.substr(Start, line.size());
SGE::StrTrimLR(func_name_args);
//check the const califier
if(m_Fntype=="const")
{
Start = func_name_args.find_first_of(" ");
m_Fntype += " ";
m_Fntype += func_name_args.substr(0, Start);
func_name_args = func_name_args.substr(Start, line.size());
}
//get function name
SGE::StrTrimLR(func_name_args);
Start = func_name_args.find_first_of("(");
if(Start==std::string::npos)
return false;
m_FnName = func_name_args.substr(0, Start);
if(m_FnName == "cvDilate")
{//juste for breakpoint...
m_FnName = m_FnName;
}
//get function short name without cv
size_t Pos = m_FnName.find_first_of("cv");
if (Pos!=std::string::npos)
m_FnShortName = m_FnName.substr(Pos+2, m_FnName.size());
else
m_FnShortName = m_FnName;
//get args
End = func_name_args.find_first_of(";");
if(Start==std::string::npos)
return false;
args = func_name_args.substr(Start, End);
m_Argstr = args;
SGE::StrTrimLR(m_FnName);
//SGE::StrTrimLR(m_Argstr);
//====================
bool loop=true;
size_t BracketPosStart=0;
size_t BracketPosStop=0;
//parse function args.
do
{
if(args=="")
break;
Start = args.find_first_of(","); // write a function that check the number of open nd close brackets then include ot disclude accordingly the arguement
if(MatchBrackets(args, BracketPosStart, BracketPosStop))
{
if(BracketPosStart<Start)
{
currArg = args.substr(1, BracketPosStop/*BracketPosStart-1*/);
//??? bug when having several optional arguments? Start = -1;
}
else
currArg = args.substr(1, Start-1);
}
else
currArg = args.substr(1, Start-1);
/*
if (MatchBrackets(currArg))
{
Start = currArg.find_first_of("(");
subarg = currArg.substr(1,Start);
//if(currArg.find_first_of(" "))
m_Args_Type.push_back(subarg.substr(1,currArg.find_first_of(" ")));
m_Args_Name.push_back(subarg.substr(currArg.find_first_of(" "),currArg.size()));
currArg = currArg.substr(currArg.find_last_of(")")+1, currArg.size());
}
*/ if (currArg.find_last_of(";")!=std::string::npos)
loop=false;
else if (Start==std::string::npos)
loop=false;
args = args.substr(Start+1,args.size());
if(args!="")
{
m_ArgsList.push_back(new CL_FctAgrs(currArg));
}
}
while(loop);//End==std::string::npos);
//Start = func_type.find_last_of(" ");
//m_FnName = currArg.substr(Start+1,func_type.size()-1);
//m_Fntype = currArg.substr(0, Start);
UpdateSwFnTypeDef();
SetID(m_FnName);
return true;
};
CL_GenSwFn::~CL_GenSwFn()
{
};
#if 0//..???moved
#define GPUCV_SWITCH__LICENSE_FILE GetGpuCVSettings()->GetShaderPath() + std::string ("../etc/sed/license.h")
#define GPUCV_SWITCH__TOP_H_FILE GetGpuCVSettings()->GetShaderPath() + std::string ("../etc/sed/cv.h/cv.top.h")
#define GPUCV_SWITCH__TOP_CPP_FILE GetGpuCVSettings()->GetShaderPath() + std::string ("../etc/sed/cv.h/cv.top.cpp")
#define GPUCV_SWITCH__BOTTOM_H_FILE GetGpuCVSettings()->GetShaderPath() + std::string ("../etc/sed/cv.h/cv.bottom.h")
#define GPUCV_SWITCH__BOTTOM_CPP_FILE GetGpuCVSettings()->GetShaderPath() + std::string ("../etc/sed/cv.h/cv.bottom.cpp")
#endif
/* To generate the following string -
void cvswSub(CvArr* src1, CvArr* src2, CvArr* dst, CvArr* mask)
*/
std::string CL_GenSwFn::GenSwFnDeclaration(ENUM_SrcFileType _fileType)
{
std::string SwitchFnDec;
SwitchFnDec = m_Fntype;
SwitchFnDec += " ";
SwitchFnDec += _GCV_SWITCH_FCT_PREFIX;//"cvgSw"
SwitchFnDec += m_FnShortName;
SwitchFnDec += "(";
for (size_t i = 0; i < m_ArgsList.size(); i++)
{
if(m_ArgsList[i]->GetName()=="")
continue;
if(i!=0)
SwitchFnDec += ", ";
SwitchFnDec += m_ArgsList[i]->GenDefinition(_fileType);
}
if(_fileType==FILETYPE_H)
SwitchFnDec += ");\n";
else
SwitchFnDec += ")\n";
return SwitchFnDec;
}
/* To generate the following -
typedef void(*CVGType_Sub)(CvArr*,CvArr*,CvArr*,CvArr*);
*/
void CL_GenSwFn::UpdateSwFnTypeDef()
{
std::string SwfnType;
std::string Type, LastPart;
std::string TempStr;
int SwfnTypeNbr = 0;
size_t Start = 0;
TempStr = m_Argstr; //( const CvArr* src, CvArr* dst, CvPoint offset, int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
//generate function typedef name
m_FnTypeDef = "TypeDef_";
m_FnTypeDef += _GCV_SWITCH_FCT_PREFIX;
m_FnTypeDef += "_";
m_FnTypeDef += m_FnShortName;
//==========================
m_SwFnType = "\ttypedef ";
m_SwFnType += m_Fntype;
m_SwFnType += "(*";
m_SwFnType += m_FnTypeDef;
m_SwFnType += ") (";
//if(!m_Args_Type.empty())
// SwfnType += m_Args_Type[0];
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
if(m_ArgsList[i]->GetName()=="")
continue;
if(SwfnTypeNbr!=0)
m_SwFnType += ", ";
//if(!m_Args_Type.empty())
if(m_ArgsList[i]->GetObjType()==Obj_Param && m_ArgsList[i]->GetConst()==true)
m_SwFnType += "const ";
m_SwFnType += m_ArgsList[i]->GetType();
SwfnTypeNbr++;
}
m_SwFnType += " ); \n";
}
/*
To generate : GPUCV_FUNCNAME("Erode");
*/
std::string CL_GenSwFn::GenSwchFnName()
{
std::string FnName;
FnName = "\tGPUCV_FUNCNAME(\"";
FnName += m_FnName;
FnName += "\");";
FnName += "\n";
return FnName;
}
//======================================================
void CL_GenSwFn::ParseArgsType()
{
GPUCV_NOTICE("Fct " << GetID() << " Parsing " << m_ArgsList.size() << "arguments");
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
GPUCV_NOTICE("\t" << i << " args: " << m_ArgsList[i]->GetType() << ","<< m_ArgsList[i]->GetName());
//fill the input/ouput image table
if((m_ArgsList[i]->GetObjType() & Obj_Input_Arr)==Obj_Input_Arr)
this->m_Src_Arr.push_back(m_ArgsList[i]->GetName());
else if((m_ArgsList[i]->GetObjType() & Obj_Output_Arr)==Obj_Output_Arr)
this->m_Dst_Arr.push_back(m_ArgsList[i]->GetName());
if(m_ArgsList[i]->GetObjType() & Obj_Mngd_GpuCV)//object need to be managed by GPUCV
SetRequireSwitching(true);
}
//parsing return type:
if(FindCheckPatternIntoStrings(this->m_Fntype, StrngsTableImage, sizeof(StrngsTableImage)/sizeof(std::string))!=-1)
SetRequireSwitching(true);
}
//======================================================
/** Generate this strings:
\code
CvArr* SrcARR[]={src1, src2, mask};
CvArr* DstARR[]={dst};
\endcode
*/
std::string CL_GenSwFn::GenSwchInOutArr()
{
std::string InArr, OutArr;
if(m_Src_Arr.size())
InArr = "\tCvArr* SrcARR[] = {";
else
InArr = "\tCvArr** SrcARR = NULL;\n";
if(m_Dst_Arr.size())
OutArr = "\tCvArr* DstARR[] = {";
else
OutArr = "\tCvArr** DstARR = NULL;\n";
for (size_t i = 0; i < m_Src_Arr.size(); i++ )
{
if(i!=0)
InArr+= ", ";
InArr+=" (CvArr*) ";
InArr+= m_Src_Arr[i];
}
for (size_t i = 0; i < m_Dst_Arr.size(); i++ )
{
if(i!=0)
OutArr+= ", ";
OutArr+=" (CvArr*) ";
OutArr+= m_Dst_Arr[i];
}
//add some comments for unknown input/output
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
if(m_ArgsList[i]->GetObjType()& (Obj_UNKOWN_Arr-Obj_Mngd_GpuCV))
{
OutArr+= "\n//Parameter ";
OutArr+= m_ArgsList[i]->GetName();
OutArr+= " has unknown input/output type\n";
}
}
if(m_Src_Arr.size()!=0)
InArr +="};\n";
if(m_Dst_Arr.size()!=0)
OutArr +="};\n";
InArr += OutArr;
return InArr;
}
//======================================================
/*
SWITCH_START_OPR(dst);
RUNOP((src1,src2,dst,mask), CVGType_AddS);
SWITCH_STOP_OPR();
*/
std::string CL_GenSwFn::GenNoSwitch()
{
std::string StRunSp="\t";
// size_t Start, End;
int Nbr=0;
if(m_Fntype!="void")
StRunSp += "return ";
StRunSp += m_FnName;
StRunSp += "(";
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
if(m_ArgsList[i]->GetName()=="")
continue;
if(Nbr!=0)
StRunSp+= ", ";
StRunSp += "(";
if(m_ArgsList[i]->GetObjType()==Obj_Param && m_ArgsList[i]->GetConst()==true)
StRunSp += "const ";
StRunSp += m_ArgsList[i]->GetType();
StRunSp += ") ";
StRunSp += m_ArgsList[i]->GetName();
Nbr++;
}
StRunSp += ");\n";
return StRunSp;
}
std::string CL_GenSwFn::GenStrtRunStop()
{
std::string StRunSp;
// size_t Start, End;
int Nbr=0;
if(m_Fntype!="void")
{
StRunSp += "\t";
StRunSp += m_Fntype;
StRunSp += " ReturnObj;";
}
StRunSp += "\tSWITCH_START_OPR(";
if (!m_Dst_Arr.empty())
StRunSp += m_Dst_Arr[0];
else
StRunSp += "NULL";
StRunSp += "); \n";
//check if we have a mask image...
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
if((m_ArgsList[i]->GetObjType() & Obj_Mask_Arr)==Obj_Mask_Arr)
{
StRunSp += "//Mask has been found, add it to params.\n";
StRunSp += "\t if(paramsobj &&";
StRunSp += m_ArgsList[i]->GetName()+")paramsobj->AddParam(\"option\", \"MASK\");\n";
}
}
StRunSp += "\tRUNOP((";
//list of args
for (size_t i = 0; i < m_ArgsList.size(); i++ )
{
if(m_ArgsList[i]->GetName()=="")
continue;
if(Nbr!=0)
StRunSp+= ", ";
StRunSp += "(";
if(m_ArgsList[i]->GetObjType()==Obj_Param && m_ArgsList[i]->GetConst()==true)
StRunSp += "const ";
StRunSp += m_ArgsList[i]->GetType();
StRunSp += ") ";
StRunSp += m_ArgsList[i]->GetName();
Nbr++;
}
StRunSp += "), ";
//==================
//Start = m_SwFnType.find_first_of("*");
//End = m_SwFnType.find_first_of(")");
StRunSp += m_FnTypeDef;
//return option...part 1
StRunSp += ", ";
if(m_Fntype!="void")
{
// StRunSp += m_Fntype;
StRunSp += " ReturnObj =";
}
//=======================
StRunSp += "); \n";
StRunSp += "\tSWITCH_STOP_OPR();\n";
//return option...part 2
if(m_Fntype!="void")
{
StRunSp += "\treturn ReturnObj;\n\n";
}
//==================
return StRunSp;
}
//======================================================
TiXmlElement* CL_GenSwFn::XMLLoad(TiXmlElement* _XML_Root)
{
SG_Assert(_XML_Root, "No XML root");
//Load id
SGE::CL_XML_BASE_OBJ<std::string>::XMLLoad(_XML_Root);
//Load values
SGE::XMLReadVal(_XML_Root,"Type", m_Fntype);
SGE::XMLReadVal(_XML_Root,"Name", m_FnName);
SGE::XMLReadVal(_XML_Root,"ShortName", m_FnShortName);
// SGE::XMLReadVal(_XML_Root,"TypeDef", m_FnTypeDef);
SGE::XMLReadVal(_XML_Root,"ArgStr", m_Argstr);
// SGE::XMLReadVal(_XML_Root,"SwType", m_SwFnType);
SGE::XMLLoadVector<CL_FctAgrs>(_XML_Root, m_ArgsList, "ArgList", "Arg");
UpdateSwFnTypeDef();
ParseArgsType();
return _XML_Root;
}
//======================================================
TiXmlElement* CL_GenSwFn::XMLSave(TiXmlElement* _XML_Root)
{
SG_Assert(_XML_Root, "No XML root");
//save id
SGE::CL_XML_BASE_OBJ<std::string>::XMLSave(_XML_Root);
//save values
SGE::XMLWriteVal(_XML_Root,"Type", m_Fntype);
SGE::XMLWriteVal(_XML_Root,"Name", m_FnName);
SGE::XMLWriteVal(_XML_Root,"ShortName", m_FnShortName);
// SGE::XMLWriteVal(_XML_Root,"TypeDef", m_FnTypeDef);
SGE::XMLWriteVal(_XML_Root,"ArgStr", m_Argstr);
// SGE::XMLWriteVal(_XML_Root,"SwType", m_SwFnType);
SGE::XMLSaveVector<CL_FctAgrs>(_XML_Root, m_ArgsList, "ArgList", "Arg");
return _XML_Root;
}
//======================================================
}//namespace GCV
|
