ErrorCode PlatformSessionImpl::onLaunchDebugServer(Session &session,
std::string const &host,
uint16_t &port,
ProcessId &pid) {
ProcessSpawner ps;
StringCollection args;
ps.setExecutable(Platform::GetSelfExecutablePath());
args.push_back("slave");
if (GetLogLevel() == kLogLevelDebug) {
args.push_back("--debug");
} else if (GetLogLevel() == kLogLevelPacket) {
args.push_back("--debug-remote");
}
ps.setArguments(args);
ps.redirectInputToNull();
ps.redirectOutputToBuffer();
ErrorCode error;
error = ps.run();
if (error != kSuccess)
return error;
error = ps.wait();
if (error != kSuccess)
return error;
if (ps.exitStatus() != 0)
return kErrorInvalidArgument;
std::istringstream ss;
ss.str(ps.output());
ss >> port >> pid;
return kSuccess;
}
void OGDFGemFrick::beforeCall() {
ogdf::GEMLayout *gem = static_cast<ogdf::GEMLayout*>(ogdfLayoutAlgo);
if (dataSet != NULL) {
int ival = 0;
double dval = 0;
StringCollection sc;
if (dataSet->get("number of rounds", ival)) {
gem->numberOfRounds(ival);
}
if (dataSet->get("minimal temperature", dval)) {
gem->minimalTemperature(dval);
}
if (dataSet->get("initial temperature", dval)) {
gem->initialTemperature(dval);
}
if (dataSet->get("gravitational constant", dval)) {
gem->gravitationalConstant(dval);
}
if (dataSet->get("desired length", dval)) {
gem->desiredLength(dval);
}
if (dataSet->get("maximal disturbance", dval)) {
gem->maximalDisturbance(dval);
}
if (dataSet->get("rotation angle", dval)) {
gem->rotationAngle(dval);
}
if (dataSet->get("oscillation angle", dval)) {
gem->oscillationAngle(dval);
}
if (dataSet->get("rotation sensitivity", dval)) {
gem->rotationSensitivity(dval);
}
if (dataSet->get("oscillation sensitivity", dval)) {
gem->oscillationSensitivity(dval);
}
if (dataSet->get(ELT_ATTRACTIONFORMULA, sc)) {
gem->attractionFormula(sc.getCurrent() + 1);
}
if (dataSet->get("minDistCC", dval))
gem->minDistCC(dval);
if (dataSet->get("pageRatio", dval))
gem->pageRatio(dval);
}
}
bool ProcFS::GetProcessArguments(pid_t pid, StringCollection &args) {
FILE *fp = ProcFS::OpenFILE(pid, "cmdline");
if (fp == nullptr)
return false;
args.clear();
std::string arg;
for (;;) {
char buf[1024], *end, *bp;
size_t nread = fread(buf, 1, sizeof(buf), fp);
if (nread == 0) {
if (!arg.empty()) {
args.push_back(arg);
}
break;
}
bp = buf, end = buf + nread;
while (bp < end) {
while (*bp != '\0') {
arg += *bp++;
}
bp++;
args.push_back(arg);
arg.clear();
}
}
std::fclose(fp);
return true;
}
void beforeCall() {
ogdf::PlanarizationGridLayout *pgl = static_cast<ogdf::PlanarizationGridLayout*>(ogdfLayoutAlgo);
if (dataSet != NULL) {
double dval = 0;
StringCollection sc;
if (dataSet->get("page ratio", dval))
pgl->pageRatio(dval);
if (dataSet->get(ELT_PLANARSUBGRAPH, sc)) {
if (sc.getCurrent() == ELT_FASTPLANAR) {
pgl->setSubgraph(new ogdf::FastPlanarSubgraph());
}
else {
pgl->setSubgraph(new ogdf::MaximalPlanarSubgraphSimple());
}
}
if (dataSet->get(ELT_EDGEINSERTION, sc)) {
if (sc.getCurrent() == ELT_FIXEDEMBEDDING) {
pgl->setInserter(new ogdf::FixedEmbeddingInserter());
}
else {
pgl->setInserter(new ogdf::VariableEmbeddingInserter);
}
}
}
}
GameAsset* Script::Create(StreamReader& reader, GameAsset* /*existingInstance*/)
{
const int length = reader.ReadInt();
Buffer buffer;
buffer.resize(length);
reader.Read(&buffer[0], length);
const int numberOfFunctions = reader.ReadInt();
FunctionTable functionTable;
functionTable.resize(numberOfFunctions);
for (int i = 0; i < numberOfFunctions; i++)
{
Function& item = functionTable[i];
item.Name = reader.ReadString();
item.Position = reader.ReadInt();
item.ArgumentStackSize = reader.ReadInt();
item.ReturnTypes.resize(reader.ReadInt());
for (std::vector<AnyType>::size_type i = 0; i < item.ReturnTypes.size(); i++)
item.ReturnTypes[i] = static_cast<AnyType>(reader.ReadInt());
item.ParameterTypes.resize(reader.ReadInt());
for (std::vector<AnyType>::size_type i = 0; i < item.ParameterTypes.size(); i++)
item.ParameterTypes[i] = static_cast<AnyType>(reader.ReadInt());
}
const int numberOfStrings = reader.ReadInt();
StringCollection stringTable;
stringTable.reserve(numberOfStrings);
for (int i = 0; i < numberOfStrings; i++)
stringTable.push_back(reader.ReadString());
return new Script(buffer, functionTable, stringTable, MoveTag());
}
void IXMLHandler::impl::startElement(const XMLCh * const uri, const XMLCh * const localname, const XMLCh* const qname, const xerces::Attributes &attrs)
{
HandlerBase::startElement(uri, localname, qname, attrs);
StringCollection<String> attributes;
XMLSize_t count = attrs.getLength();
for(XMLSize_t i = 0; i < count; i++)
{
attributes.set(attrs.getLocalName(i), attrs.getValue(i));
}
m_handler->onStartElement(localname, attributes);
}
void TestDirectory::TestGetFilesWithMask()
{
typedef std::vector<std::tstring> StringCollection;
StringCollection fileNames = Workshare::System::IO::Directory::GetFiles(TEST_FOLDER + _T("\\TestGetFiles"), _T("*.doc"));
assertEquals(2, (long)fileNames.size());
// make all fileNames lowercase, so we can find them.
std::for_each(fileNames.begin(), fileNames.end(), MakeFileNameLowerCase);
StringCollection::iterator fileName = std::find(fileNames.begin(), fileNames.end(), tolower(TEST_FOLDER + _T("\\testgetfiles\\filea.doc")));
assertMessage(fileName != fileNames.end(), _T("Expected to find [") + TEST_FOLDER + _T("\\testgetfiles\\filea.doc] in the returned list"));
fileName = std::find(fileNames.begin(), fileNames.end(), tolower(TEST_FOLDER + _T("\\testgetfiles\\fileb.doc")));
assertMessage(fileName != fileNames.end(), _T("Expected to find [") + TEST_FOLDER + _T("\\testgetfiles\\fileb.doc] in the returned list"));
}
bool TestMultiPackageHostContext::FromClientId(std::wstring const& clientId, TestMultiPackageHostContext & testMultiPackageHostContext)
{
StringCollection collection;
StringUtility::Split<wstring>(clientId, collection, TestMultiPackageHostContext::ParamDelimiter);
if(collection.size() == 2)
{
Federation::NodeId nodeId;
TestSession::FailTestIfNot(Federation::NodeId::TryParse(collection[0], nodeId), "Could not parse NodeId: {0}", clientId);
testMultiPackageHostContext = TestMultiPackageHostContext(nodeId.ToString(), collection[1]);
return true;
}
else
{
return false;
}
}
vector<ServiceMetric> PlacementAndLoadBalancingUnitTest::CreateMetrics(wstring metrics)
{
StringCollection metricCollection;
StringUtility::Split<wstring>(metrics, metricCollection, ItemDelimiter);
vector<ServiceMetric> metricList;
for (wstring const& metricStr : metricCollection)
{
StringCollection metricProperties;
StringUtility::Split<wstring>(metricStr, metricProperties, PairDelimiter);
ASSERT_IFNOT(metricProperties.size() == 4, "Metric error");
metricList.push_back(ServiceMetric(move(metricProperties[0]), Common::Double_Parse(metricProperties[1]), _wtoi(metricProperties[2].c_str()), _wtoi(metricProperties[3].c_str())));
}
return metricList;
}
vector<ReplicaDescription> PlacementAndLoadBalancingUnitTest::CreateReplicas(wstring replicas, std::vector<bool>& isReplicaUp)
{
StringCollection replicaSet;
vector<ReplicaDescription> replicaDescription;
StringUtility::Split<wstring>(replicas, replicaSet, ItemDelimiter);
if (replicaSet.size() != isReplicaUp.size())
{
return replicaDescription;
}
for (int i = 0; i < replicaSet.size(); i++)
{
replicaDescription.push_back(CreateReplicas(replicaSet[i], isReplicaUp[i])[0]);
}
return replicaDescription;
}
map<wstring, uint> PlacementAndLoadBalancingUnitTest::CreateCapacities(std::wstring capacityStr)
{
map<wstring, uint> capacities;
if (!capacityStr.empty())
{
StringCollection capacityCollection;
StringUtility::Split<wstring>(capacityStr, capacityCollection, ItemDelimiter);
for (int i = 0; i < capacityCollection.size(); ++i)
{
StringCollection capacityPair;
StringUtility::Split<wstring>(capacityCollection[i], capacityPair, PairDelimiter);
ASSERT_IFNOT(capacityPair.size() == 2, "Capacity error");
capacities.insert(make_pair(capacityPair[0], _wtoi(capacityPair[1].c_str())));
}
}
return capacities;
}
bool UnreliableTransportConfiguration::AddSpecification(std::wstring const & name, std::wstring const & data)
{
StringCollection params;
StringUtility::Split<wstring>(data, params, L" ");
wstring source = (params.size() > 0 ? params[0] : wstring());
wstring destination = (params.size() > 1 ? params[1] : wstring());
wstring action = (params.size() > 2 ? params[2] : wstring());
double probability = (params.size() > 3 ? Common::Double_Parse(params[3]) : 1.0);
TimeSpan delay = (params.size() > 4 ? ParseTimeSpan(params[4]) : TimeSpan::MaxValue);
TimeSpan delaySpan = (params.size() > 5 ? ParseTimeSpan(params[5]) : TimeSpan::Zero);
int priority = (params.size() > 6 ? Common::Int32_Parse(params[6]) : 0);
int applyCount = (params.size() > 7 ? Common::Int32_Parse(params[7]) : -1);
return AddSpecification(make_unique<UnreliableTransportSpecification>(name, source, destination, action, probability, delay, delaySpan, priority, applyCount));
}
map<wstring, ApplicationCapacitiesDescription> PlacementAndLoadBalancingUnitTest::CreateApplicationCapacities(wstring appCapacities)
{
map<std::wstring, ApplicationCapacitiesDescription> capacityDesc;
StringCollection capacityCollection;
StringUtility::Split<wstring>(appCapacities, capacityCollection, ItemDelimiter);
for (wstring const& metricStr : capacityCollection)
{
StringCollection metricProperties;
StringUtility::Split<wstring>(metricStr, metricProperties, PairDelimiter);
ASSERT_IFNOT(metricProperties.size() == 4, "CreateApplicationCapacities metric error");
wstring metricName = metricProperties[0];
capacityDesc.insert(make_pair(metricName,
ApplicationCapacitiesDescription(move(metricProperties[0]), _wtoi(metricProperties[1].c_str()), _wtoi(metricProperties[2].c_str()), _wtoi(metricProperties[3].c_str()))));
}
return capacityDesc;
}
void GetEthernetList(StringCollection& dev)
{
CommandModel cmd;
cmd.FuncName = FuncEthernetGetAll;
cmd.Password = true;
Value result;
Rpc::Call(cmd, result);
ENUM_LIST(EthernetInterface, List<EthernetInterface>(result), e)
{
EthernetInterface eth(*e);
dev.insert(eth.Dev);
}
void beforeCall() {
ogdf::TreeLayout *tree = static_cast<ogdf::TreeLayout*>(ogdfLayoutAlgo);
if (dataSet != NULL) {
double dval = 0;
bool bval = false;
StringCollection sc;
if (dataSet->get("siblings distance", dval))
tree->siblingDistance(dval);
if (dataSet->get("subtrees distance", dval))
tree->subtreeDistance(dval);
if (dataSet->get("levels distance", dval))
tree->levelDistance(dval);
if (dataSet->get("trees distance", dval))
tree->treeDistance(dval);
if (dataSet->get("orthogonal layout", bval))
tree->orthogonalLayout(bval);
if (dataSet->get(ELT_ORIENTATION, sc)) {
if (sc.getCurrent() == ELT_TOPTOBOTTOM) {
tree->orientation(ogdf::topToBottom);
}
else if (sc.getCurrent() == ELT_BOTTOMTOTOP) {
tree->orientation(ogdf::bottomToTop);
}
else if (sc.getCurrent() == ELT_LEFTTORIGHT) {
tree->orientation(ogdf::leftToRight);
}
else {
tree->orientation(ogdf::rightToLeft);
}
}
if (dataSet->get(ELT_ROOTSELECTION, sc)) {
if (sc.getCurrent() == ELT_ROOTSOURCE) {
tree->rootSelection(ogdf::TreeLayout::rootIsSource);
}
else if (sc.getCurrent() == ELT_ROOTSINK) {
tree->rootSelection(ogdf::TreeLayout::rootIsSink);
}
else {
tree->rootSelection(ogdf::TreeLayout::rootByCoord);
}
}
}
}
void beforeCall() {
ogdf::SugiyamaLayout *sugiyama = static_cast<ogdf::SugiyamaLayout*>(ogdfLayoutAlgo);
if (dataSet != NULL) {
int ival = 0;
double dval = 0;
bool bval = false;
StringCollection sc;
if (dataSet->get("fails", ival))
sugiyama->fails(ival);
if (dataSet->get("runs", ival))
sugiyama->runs(ival);
if (dataSet->get("arrangeCCS", bval))
sugiyama->arrangeCCs(bval);
if (dataSet->get("minDistCC", dval))
sugiyama->minDistCC(dval);
if (dataSet->get("pageRatio", dval))
sugiyama->pageRatio(dval);
if (dataSet->get("alignBaseClasses", bval))
sugiyama->alignBaseClasses(bval);
if (dataSet->get("alignSiblings", bval))
sugiyama->alignSiblings(bval);
if (dataSet->get(ELT_RANKING, sc)) {
if (sc.getCurrent() == ELT_LONGESTPATHRANKING) {
sugiyama->setRanking(new ogdf::LongestPathRanking());
}
else if(sc.getCurrent() == ELT_OPTIMALRANKING) {
sugiyama->setRanking(new ogdf::OptimalRanking());
}
else
sugiyama->setRanking(new ogdf::CoffmanGrahamRanking());
}
if (dataSet->get(ELT_TWOLAYERCROSS, sc)) {
if (sc.getCurrent() == ELT_BARYCENTER) {
sugiyama->setCrossMin(new ogdf::BarycenterHeuristic());
}
else if (sc.getCurrent() == ELT_MEDIAN) {
sugiyama->setCrossMin(new ogdf::MedianHeuristic());
}
else if(sc.getCurrent()==ELT_SPLIT) {
sugiyama->setCrossMin(new ogdf::SplitHeuristic());
}
else if(sc.getCurrent()==ELT_SIFTING) {
sugiyama->setCrossMin(new ogdf::SiftingHeuristic());
}
else if(sc.getCurrent()==ELT_GREEDYINSERT) {
sugiyama->setCrossMin(new ogdf::GreedyInsertHeuristic());
}
else
sugiyama->setCrossMin(new ogdf::GreedySwitchHeuristic());
}
if(dataSet->get(ELT_HIERARCHYLAYOUT, sc)) {
double nodeDistance = 3;
double layerDistance = 3;
bool fixedLayerDistance = true;
dataSet->get("node distance", nodeDistance);
dataSet->get("layer distance", layerDistance);
dataSet->get("fixed layer distance", fixedLayerDistance);
if(sc.getCurrent()==ELT_FASTHIERARCHY) {
ogdf::FastHierarchyLayout *fhl = new FastHierarchyLayout();
fhl->nodeDistance(nodeDistance);
fhl->layerDistance(layerDistance);
fhl->fixedLayerDistance(fixedLayerDistance);
sugiyama->setLayout(fhl);
}
else {
sugiyama->setLayout(new ogdf::FastSimpleHierarchyLayout(static_cast<int>(nodeDistance), static_cast<int>(layerDistance)));
}
}
}
}
StringCollection::StringCollection(const StringCollection &sc){
#ifdef USE_EMBEDDED_CLASSNAMES
setClassName(__xvr2_Util_StringCollection);
#endif
insert(begin(), sc.begin(), sc.end());
}
// namespace
// {
static void PrintStringCollection(StringCollection const & coll, wstring const & header)
{
Trace.WriteInfo(TraceType, "{0}:", header);
for_each(coll.begin(), coll.end(), [](wstring const & elem) { Trace.WriteInfo(TraceType, "\t\"{0}\"", elem); });
}
//====================================================================
bool ConnectedComponentPacking::run() {
LayoutProperty *layout = NULL;
SizeProperty *size = NULL;
DoubleProperty *rotation = NULL;
string complexity("auto");
workingGraph = graph->addCloneSubGraph("workingGraph");
if ( dataSet!=NULL ) {
dataSet->get("coordinates", layout);
getNodeSizePropertyParameter(dataSet, size);
dataSet->get("rotation", rotation);
StringCollection complexityCol;
if (dataSet->get("complexity", complexityCol))
complexity = complexityCol.getCurrentString();
}
if (layout==NULL)
layout = workingGraph->getProperty<LayoutProperty>("viewLayout");
if (size==NULL)
size = workingGraph->getProperty<SizeProperty>("viewSize");
if (rotation==NULL)
rotation = workingGraph->getProperty<DoubleProperty>("viewRotation");
if (complexity=="none")
complexity = "auto";
// compute the connected components's subgraphs
std::vector<std::set<node> > components;
ConnectedTest::computeConnectedComponents(workingGraph, components);
for (unsigned int i = 0; i < components.size(); ++i) {
workingGraph->inducedSubGraph(components[i]);
}
vector<Rectangle<float> > rectangles;
Iterator<Graph *> *it = workingGraph->getSubGraphs();
while(it->hasNext()) {
Graph *sg = it->next();
BoundingBox tmp = tlp::computeBoundingBox(sg, layout, size, rotation);
Rectangle<float> tmpRec;
tmpRec[1][0] = tmp[1][0] + spacing;
tmpRec[1][1] = tmp[1][1] + spacing;
tmpRec[0][0] = tmp[0][0] + spacing;
tmpRec[0][1] = tmp[0][1] + spacing;
assert(tmpRec.isValid());
rectangles.push_back(tmpRec);
}
delete it;
if (complexity == "auto") {
if (rectangles.size()<25) {
complexity="n5";
}
else if (rectangles.size()<50) {
complexity="n4logn";
}
else if (rectangles.size()<100) {
complexity="n4";
}
else if (rectangles.size()<150) {
complexity="n3logn";
}
else if (rectangles.size()<250) {
complexity="n3";
}
else if (rectangles.size()<500) {
complexity="n2logn";
}
else if (rectangles.size()<1000) {
complexity="n2";
}
else if (rectangles.size()<5000) {
complexity="nlogn";
}
else
complexity="n";
}
vector<Rectangle<float> > rectanglesBackup(rectangles);
RectanglePackingLimitRectangles(rectangles, complexity.c_str(), pluginProgress);
Iterator<node> *itN = graph->getNodes();
while(itN->hasNext()) {
node n = itN->next();
layoutResult->setNodeValue(n, layout->getNodeValue(n));
}
delete itN;
Iterator<edge> *itE = graph->getEdges();
while(itE->hasNext()) {
edge e = itE->next();
layoutResult->setEdgeValue(e, layout->getEdgeValue(e));
}
delete itE;
unsigned int i = 0;
it = workingGraph->getSubGraphs();
while(it->hasNext()) {
Graph *sg = it->next();
Coord move(rectangles[i][0][0]-rectanglesBackup[i][0][0], rectangles[i][0][1]-rectanglesBackup[i][0][1], 0);
layoutResult->translate(move, sg);
++i;
}
delete it;
graph->delAllSubGraphs(workingGraph);
return true;
}
static void CheckStringCollectionsEquality(StringCollection & coll1, StringCollection & coll2)
{
sort(coll1.begin(), coll1.end());
sort(coll2.begin(), coll2.end());
BOOST_REQUIRE(coll1 == coll2);
}
vector<ReplicaDescription> PlacementAndLoadBalancingUnitTest::CreateReplicas(wstring replicas, bool isUp)
{
vector<ReplicaDescription> replicaVector;
// format [replica1], [replica2], ...
// each replica: [replicaRole]/[nodeIndex]/[IsToBePromoted][IsMoveInProgress][IsToBeDropped][IsInBuild]
// replicaRole: P or S or SB
// the last three descriptions optional inputs: PDB; treated as false by default
StringCollection placement;
StringUtility::Split<wstring>(replicas, placement, ItemDelimiter);
for (wstring const& replica : placement)
{
StringCollection replicaFields;
StringUtility::Split<wstring>(replica, replicaFields, PairDelimiter);
ReplicaRole::Enum role = ReplicaRole::None;
Reliability::ReplicaStates::Enum state = Reliability::ReplicaStates::Ready;
StringUtility::TrimSpaces(replicaFields[0]);
if (replicaFields[0] == L"P")
{
role = ReplicaRole::Primary;
}
else if (replicaFields[0] == L"S" || replicaFields[0] == L"I")
{
role = ReplicaRole::Secondary;
}
else if (replicaFields[0] == L"N")
{
role = ReplicaRole::None;
}
else if (replicaFields[0] == L"SB")
{
role = ReplicaRole::StandBy;
state = Reliability::ReplicaStates::StandBy;
}
else if (replicaFields[0] == L"D")
{
role = ReplicaRole::Dropped;
state = Reliability::ReplicaStates::Dropped;
}
int nodeIndex = _wtoi(replicaFields[1].c_str());
Reliability::ReplicaFlags::Enum flags = Reliability::ReplicaFlags::None;
if (replicaFields.size() >= 3)
{
wstring properties = replica.substr(replicaFields[0].length() + replicaFields[1].length() + 2);
if (StringUtility::Contains<wstring>(properties, L"B"))
{
state = Reliability::ReplicaStates::InBuild;
}
if (StringUtility::Contains<wstring>(properties, L"I"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::PrimaryToBeSwappedOut);
}
if (StringUtility::Contains<wstring>(properties, L"J"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::PrimaryToBePlaced);
}
if (StringUtility::Contains<wstring>(properties, L"K"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::ReplicaToBePlaced);
}
if (StringUtility::Contains<wstring>(properties, L"V"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::MoveInProgress);
}
if (StringUtility::Contains<wstring>(properties, L"D"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::ToBeDroppedByFM);
}
if (StringUtility::Contains<wstring>(properties, L"R"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::ToBeDroppedByPLB);
}
if (StringUtility::Contains<wstring>(properties, L"T"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::ToBeDroppedForNodeDeactivation);
}
if (StringUtility::Contains<wstring>(properties, L"P"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::ToBePromoted);
}
if (StringUtility::Contains<wstring>(properties, L"N"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::PendingRemove);
}
if (StringUtility::Contains<wstring>(properties, L"Z"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::Deleted);
}
if (StringUtility::Contains<wstring>(properties, L"L"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::PreferredPrimaryLocation);
}
if (StringUtility::Contains<wstring>(properties, L"E"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::EndpointAvailable);
}
if (StringUtility::Contains<wstring>(properties, L"M"))
{
flags = static_cast<Reliability::ReplicaFlags::Enum>(flags ^ Reliability::ReplicaFlags::PreferredReplicaLocation);
}
}
replicaVector.push_back(ReplicaDescription(
CreateNodeInstance(nodeIndex, 0),
role,
state,
isUp, // isUp
flags));
}
return replicaVector;
}
///===========================================================
bool ReachableSubGraphSelection::run() {
unsigned int maxDistance = 5;
StringCollection edgeDirectionCollecion;
EDGE_TYPE edgeDirection=DIRECTED;
BooleanProperty * startNodes=graph->getProperty<BooleanProperty>("viewSelection");
if ( dataSet!=NULL) {
dataSet->get("distance", maxDistance);
//Get the edge orientation
if(dataSet->get("edges direction",edgeDirectionCollecion)) {
if(edgeDirectionCollecion.getCurrentString() == edgesDirectionLabels[0]) {
edgeDirection = DIRECTED;
}
else if(edgeDirectionCollecion.getCurrentString()== edgesDirectionLabels[1]) {
edgeDirection = INV_DIRECTED;
}
else if(edgeDirectionCollecion.getCurrentString()== edgesDirectionLabels[2]) {
edgeDirection = UNDIRECTED;
}
}
else {
//If the new parameter is not defined search for the old one.
int direction=0;
if(dataSet->get("direction",direction)) {
switch(direction) {
case 0:
edgeDirection = DIRECTED;
break;
case 1:
edgeDirection = INV_DIRECTED;
break;
case 2:
edgeDirection = UNDIRECTED;
}
}
}
dataSet->get("startingnodes", startNodes);
}
result->setAllEdgeValue(false);
result->setAllNodeValue(false);
if (startNodes) {
Iterator<node>* itN = startNodes->getNodesEqualTo(true);
std::set<node> reachables;
// iterate on startNodes add them and their reachables
while (itN->hasNext()) {
node current = itN->next();
reachables.insert(current);
reachableNodes(graph, current, reachables, maxDistance,
edgeDirection);
}
delete itN;
std::set<node>::const_iterator itr = reachables.begin();
std::set<node>::const_iterator ite = reachables.end();
// select nodes
while (itr != ite) {
result->setNodeValue((*itr), true);
++itr;
}
// select corresponding edges
Iterator<edge> *itE = graph->getEdges();
while(itE->hasNext()) {
edge e = itE->next();
const std::pair<node, node>& ends = graph->ends(e);
if (result->getNodeValue(ends.first) &&
result->getNodeValue(ends.second))
result->setEdgeValue(e, true);
}
delete itE;
}
return true;
}