GPStreamADF::GPStreamADF(const GPFunctionTree* tree)
{
auto root = tree->root();
auto rootfunc = root->data().pFunc;
GPASSERT(NULL!=rootfunc);
auto lists = root->display();
std::map<const GPAbstractPoint*, GPPtr<Point>> maplists;
/*Create All Function*/
for (auto p : lists)
{
auto pp = (GPFunctionTreePoint*)p;
if (GPFunctionTreePoint::INPUT == pp->type())
{
GPPtr<Point> cp = new SP(NULL);
mSources.push_back(cp);
mInputPos.push_back(pp->data().iInput);
maplists.insert(std::make_pair(p, cp));
}
else
{
GPPtr<Point> cp = new CP(new GPComputePoint(pp->data().pFunc));
mFunctions.push_back((CP*)(cp.get()));
maplists.insert(std::make_pair(p, cp));
}
}
/*Dest*/
auto rootcp = maplists.find(root)->second;
for (int i=0; i<rootfunc->outputType.size(); ++i)
{
GPPtr<Point> dst = (new DP(rootfunc->outputType[i]));
dst->connectInput(rootcp.get(), 0);
rootcp->connectOutput(dst, i);
mDest.push_back(dst);
}
/*Connect*/
for (auto p : lists)
{
auto PP = maplists.find(p)->second;
auto func = ((GPFunctionTreePoint*)p)->data().pFunc;
size_t n = p->getChildrenNumber();
GPASSERT(!(NULL!=func && n==0));
for (int i=0; i<n; ++i)
{
auto pc = p->getChild(i);
auto PC = maplists.find(pc)->second;
PP->connectInput(PC.get(), i);
PC->connectOutput(PP, 0);
if (pc->getChildrenNumber() == 0)
{
SP* s = (SP*)PC.get();
s->setType(func->inputType[i]);
}
}
}
}
GPStreamADF::GPStreamADF(const GPTreeNode* n, const GPFunctionDataBase* base)
{
auto children = n->getChildren();
GPASSERT(3 == children.size());
mSources.clear();
/*Source*/
std::map<std::string, Point*> sp_map;
{
auto source = children[0];
GPASSERT(source->name() == "Source");
for (auto types : source->getChildren())
{
auto source_name = types->name();
auto type_name = types->attr();
auto spoint = new SP(base->vQueryType(type_name));
mSources.push_back(spoint);
sp_map.insert(std::make_pair(source_name, spoint));
}
for (int i=0; i<mSources.size(); ++i)
{
mInputPos.push_back(i);
}
}
std::map<std::string, GPPtr<Point>> cp_map;
/*ComputePoints*/
{
auto computepoints_info = children[1];
GPASSERT(computepoints_info->name() == "ComputePoint");
/*Collect all points firstly*/
for (auto compute_info : computepoints_info->getChildren())
{
auto function = base->vQueryFunction(GPStringHelper::cleanString(compute_info->attr()));
if (NULL == function)
{
FUNC_PRINT_ALL(compute_info->attr().c_str(), s);
}
GPASSERT(NULL!=function);
auto node = new CP(new GPComputePoint(function));
mFunctions.push_back(node);
cp_map.insert(std::make_pair(compute_info->name(), node));
}
/*Now Connect*/
for (auto compute_info : computepoints_info->getChildren())
{
auto function = base->vQueryFunction(GPStringHelper::cleanString(compute_info->attr()));
auto this_node = cp_map.find(compute_info->name())->second;
for (auto info : compute_info->getChildren())
{
if (info->name() == "Input")
{
auto node_names = GPStringHelper::divideString(info->attr());
for (int i=0; i<node_names.size(); ++i)
{
auto name = node_names[i];
auto s_iter = sp_map.find(name);
if (s_iter != sp_map.end())
{
s_iter->second->connectOutput(this_node, 0);
this_node->connectInput(s_iter->second, i);
continue;
}
auto c_iter = cp_map.find(name);
GPASSERT(c_iter!=cp_map.end());
this_node->connectInput(c_iter->second.get(), i);
}
}
if (info->name() == "Output")
{
auto node_names = GPStringHelper::divideString(info->attr());
GPASSERT(function->outputType.size() == node_names.size());
auto n = function->outputType.size();
for (size_t i=0; i<n; ++i)
{
auto name = node_names[i];
auto cp_iter = cp_map.find(name);
if (cp_iter!=cp_map.end())
{
auto output = cp_iter->second;
this_node->connectOutput(output, 0);
continue;
}
auto dst = new DP(function->outputType[i]);
mDest.push_back(dst);
dst->connectInput(this_node.get(), 0);
this_node->connectOutput(dst, 0);
dst->addRef();
}
}
}
}
}
/*Load Status*/
{
auto status_tn = children[2];
GPASSERT(status_tn->name() == "Status");
auto status_values = GPStringHelper::divideString(status_tn->attr());
if (status_values.size() > 0)
{
GPASSERT(status_values.size() == this->vMap(NULL));
GPPtr<GPParameter> para = new GPParameter((int)(status_values.size()));
for (int i=0; i<status_values.size(); ++i)
{
std::istringstream number(status_values[i]);
number >> para->attach()[i];
}
this->vMap(para.get());
}
}
GPStreamADF::GPStreamADF(const GPMultiLayerTree* opttree)
{
GPASSERT(NULL!=opttree);
auto layers = opttree->layers();
std::map<const GPFunctionTreePoint*, GPPtr<Point>> maplists;
GPASSERT(layers.size()>=1);
/*Create All CP*/
for (auto iter : layers)
{
for (auto p : iter.second->display())
{
auto pp = (GPFunctionTreePoint*)p;
if (GPFunctionTreePoint::FUNCTION == pp->type())
{
GPPtr<Point> cp = new CP(new GPComputePoint(pp->data().pFunc));
mFunctions.push_back((CP*)(cp.get()));
maplists.insert(std::make_pair(pp, cp));
}
}
}
/*Connect Already Exists CP*/
for (auto cpiter : maplists)
{
auto tree = cpiter.first;
auto output = cpiter.second;
size_t n = tree->getChildrenNumber();
for (int i=0; i<n; ++i)
{
auto _p = GPCONVERT(const GPFunctionTreePoint, tree->getChild(i));
if (maplists.find(_p)!=maplists.end())
{
auto input = maplists.find(_p)->second;
input->connectOutput(output, 0);
output->connectInput(input.get(), i);
}
}
}
/*Create All Inputs*/
std::map<int, std::vector<std::pair<const GPFunctionTreePoint*, int>>> inputLists;
for (auto iter : maplists)
{
auto p = iter.first;
size_t n = p->getChildrenNumber();
for (int i=0; i<n; ++i)
{
auto _p = GPCONVERT(const GPFunctionTreePoint, p->getChild(i));
if (GPFunctionTreePoint::INPUT == _p->type())
{
int pos = _p->data().iInput;
if (inputLists.find(pos) == inputLists.end())
{
std::vector<std::pair<const GPFunctionTreePoint*, int>> t;
inputLists.insert(std::make_pair(pos, t));
}
inputLists.find(pos)->second.push_back(std::make_pair(p, i));
}
}
}
/*Replace inputpos from layers*/
for (auto iter : layers)
{
if (iter.first >= 0)
{
auto replacePos = iter.first;
auto outputPoints = inputLists.find(replacePos)->second;
GPPtr<Point> transform = new TP((int)outputPoints.size());
mTPS.push_back((TP*)transform.get());
GPPtr<Point> inputPoint = maplists.find(iter.second.get())->second;
inputPoint->connectOutput(transform, 0);
transform->connectInput(inputPoint.get(), 0);
for (int j=0; j<outputPoints.size(); ++j)
{
GPPtr<Point> transform_node = new TP(1);
mTPS.push_back((TP*)transform_node.get());
transform->connectOutput(transform_node, j);
transform_node->connectInput(transform.get(), 0);
auto o_tree = outputPoints[j];
auto o = maplists.find(o_tree.first)->second;
o->connectInput(transform_node.get(), o_tree.second);
transform_node->connectOutput(o, 0);
}
inputLists.erase(replacePos);
}
}
/*Create SP*/
GPASSERT(inputLists.size()>0);
for (auto iter : inputLists)
{
for (auto v : iter.second)
{
auto tree = v.first;
GPASSERT(GPFunctionTreePoint::FUNCTION == tree->type());
auto pos = v.second;
auto point = maplists.find(tree)->second;
GPPtr<Point> source_point = new SP(tree->data().pFunc->inputType[pos]);
source_point->connectOutput(point, 0);
point->connectInput(source_point.get(), pos);
mSources.push_back(source_point);
mInputPos.push_back(iter.first);
}
}
/*Create DP*/
for (auto iter : opttree->layers())
{
if(iter.first < 0)
{
GPPtr<Point> input = maplists.find(iter.second.get())->second;
for (size_t i=0; i<iter.second->data().pFunc->outputType.size(); ++i)
{
GPPtr<Point> dst = new DP(iter.second->data().pFunc->outputType[i]);
mDest.push_back(dst);
dst->connectInput(input.get(), 0);
input->connectOutput(dst, 0);
}
}
}
}
/// Connect the output file to the service with open mode.
StatusCode PersistencySvc::connectOutput(const std::string& outputFile,
const std::string& /* openMode */) {
return connectOutput(outputFile);
}
