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); }