/**
@brief Performs a topological sort on the tree
*
*The nodes on the vector comprise the tree.
@param theNodes vector containing node pointers
@return void
**/
void topologicalSort(vector<Node*> theNodes)
{
Node * temp = theNodes[0];
string out = "";
while(temp->getOutNodes().size() > 0)
{
vector<Node*> myNodes = temp->getInNodes();
for(int x = 0; x < myNodes.size(); x++)
{
int pos = out.find(myNodes[x]->getName());
if(pos != -1)
continue;
out = out + myNodes[x]->getName() + '\t';
}
out = out + temp->getName() + '\t';
myNodes = temp->getOutNodes();
temp = myNodes[0];
}
vector<Node*> myNodes = temp->getInNodes();
for(int x = 0; x < myNodes.size(); x++)
{
int pos = out.find(myNodes[x]->getName());
if(pos != -1)
continue;
out = out + myNodes[x]->getName() + '\t';
}
out = out + temp->getName();
cout << out << endl;
}
bool NodeDatabase::removeNode(Node& n) {
auto it = nodes.find(n.getName());
if(it == nodes.end()) {
return NULL;
} else {
vector<Node*>* children = it->second;
for(auto i = children->begin(); i != children->end(); ++i) {
if((*i)->getName() == n.getName()) {
children->erase(i);
return true;
}
}
}
}
Node *Node::nextTraversalByName(const char *nameString) const
{
if (nameString == NULL)
return NULL;
String name(nameString);
for (Node *node = nextTraversal(); node != NULL; node = node->nextTraversal()) {
if (node->getName() != NULL) {
if (name.compareTo(node->getName()) == 0)
return node;
}
}
return NULL;
}
string TreeTemplateTools::nodeToParenthesis(const Node& node, bool writeId)
{
ostringstream s;
if (node.hasNoSon())
{
s << node.getName();
}
else
{
s << "(";
s << nodeToParenthesis(*node[0], writeId);
for (int i = 1; i < static_cast<int>(node.getNumberOfSons()); i++)
{
s << "," << nodeToParenthesis(*node[i], writeId);
}
s << ")";
}
if (writeId)
{
if (node.hasNoSon())
s << "_";
s << node.getId();
}
else
{
if (node.hasBranchProperty(TreeTools::BOOTSTRAP))
s << (dynamic_cast<const Number<double>*>(node.getBranchProperty(TreeTools::BOOTSTRAP))->getValue());
}
if (node.hasDistanceToFather())
s << ":" << node.getDistanceToFather();
return s.str();
}
//Input: nothing
//Output nothing
//Purpose: Removes one item from the front of the Queue and returns it
std::string Queue:: dequeue(int idNumber){
Node* before = nullptr;
Node* middle = first;
Node* after = middle->getNext();
for (int i = 0; i < size; i++) {
if( idNumber == middle->getIdNumber() ){
std:: string removedOneName = middle->getName();
int removedOneIdNumber = middle->getIdNumber();
std:: string removedOne = removedOneName + " ID Number: " + std::to_string(removedOneIdNumber);
if(before == nullptr){
first = after;
}
else{
before->setNext(after);
}
size--;
return removedOne;
}
before = middle;
middle = after;
after = after->getNext();
}
return "No one with that ID Number found";
}
Node *Utilities::findNode(Graph *_g, const std::string &_name)
{
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(".");
tokenizer tok(_name, sep);
tokenizer::iterator beg = tok.begin();
tokenizer::iterator beg1 = beg;
int i = 0;
//this solution could be done a bit better
for(; beg != tok.end(); beg++)
{
i++;
}
if(i==2)
{
std::string node = *beg1;
std::string id = *++beg1;
int i = std::stoi(id);
Node *n = _g->getNode(node, i);
std::cout<<"found node "<<n->getName()<<'\n';
return n;
}
else
{
std::cout<<"Node path is wrong\n";
return new Node;
}
}
void Model::getNodeList(Model::AnimationNodeMap &nodelist)
{
std::queue<Node*> currentnodes;
currentnodes.push(rootnode);
while (currentnodes.size() > 0)
{
Node *node = currentnodes.front();
currentnodes.pop();
AnimationNode *newnode = new AnimationNode;
newnode->name = node->getName();
if (node->getParent())
newnode->parent = nodelist[node->getParent()->getName()];
else
newnode->parent = 0;
newnode->transformation = node->getTransformation();
newnode->transinverse = node->getInvTrans();
newnode->dirty = true;
nodelist.insert(std::make_pair(newnode->name, newnode));
// Child nodes
const std::vector<Node*> &children = node->getChildren();
for (unsigned int i = 0; i < children.size(); i++)
{
currentnodes.push(children[i]);
}
}
}
bool TreeTemplateTools::haveSameOrderedTopology(const Node& n1, const Node& n2)
{
if (n1.hasNoSon() && n2.hasNoSon() && n1.getName() != n2.getName())
return false;
size_t nl1 = n1.getNumberOfSons();
size_t nl2 = n2.getNumberOfSons();
if (nl1 != nl2)
return false;
bool test = true;
for (size_t i = 0; test && i < n1.getNumberOfSons(); ++i)
{
test &= haveSameOrderedTopology(*n1.getSon(i), *n2.getSon(i));
}
return test;
}
void Data::print(bool isMorph) {
int maxLen = treePtr->lengthOfLongestName();
for (int n=0; n<treePtr->getNumberOfDownPassNodes(); n++)
{
Node* p = treePtr->getDownPassNode(n);
if ( treePtr->isExtantTaxon(p) == true || treePtr->isFossilTaxon(p) == true )
{
std::string s = p->getName();
std::cout << s << " ";
for (int i=0; i<maxLen-s.length(); i++)
std::cout << " ";
for (int c=0; c<numChar; c++)
{
if ( isMorph == true )
{
std::cout << dataMatrix[p->getIndex()][c];
}
else
{
if (s[0] == 'F')
std::cout << "?";
else
std::cout << convertToDNA(dataMatrix[p->getIndex()][c]);
}
}
std::cout << std::endl;
}
}
}
void CallStackCollector::sample(char const * const name)
{
if (ms_clear)
clear();
if (!ms_enabled)
return;
//-- Get the desired node
Node * node = 0;
ConstCharCrcString const crcName(name);
NodeMap::iterator iter = ms_nodeMap.find((const CrcString*)&crcName);
if (iter != ms_nodeMap.end())
node = iter->second;
else
{
node = new Node(name);
ms_nodeMap.insert(std::make_pair(&node->getName(), node));
}
//-- Sample the callstack
uint32 callStack[CALLSTACK_DEPTH];
DebugHelp::getCallStack(&callStack[0], CALLSTACK_DEPTH);
//-- Add to the node
node->addCallStack(&callStack[0]);
}
/**
* Gets the spelling alternatives to the specified query terms.
* Returns a map with term as key and an Alternative object as value for each query term
*/
std::map<std::string, Alternative> getAlternatives() {
if (!_alternatives.empty())
return _alternatives;
_alternatives.clear();
NodeSet alternatives = doc->FindFast("cps:reply/cps:content/alternatives_list/alternatives", true);
for (unsigned int i = 0; i < alternatives.size(); i++) {
Node *el = alternatives[i]->getFirstChild();
Alternative alt;
while (el != NULL) {
std::string name = el->getName();
if (name == "to")
alt.to = el->getContent();
else if (name == "count")
alt.count = atoi(el->getContentPtr());
else if (name == "word") {
Alternative::Word w;
w.count = atoi(el->getAttribute("count")->getContentPtr());
w.h = atof(el->getAttribute("h")->getContentPtr());
w.idif = atof(el->getAttribute("idif")->getContentPtr());
w.cr = atof(el->getAttribute("cr")->getContentPtr());
w.content = el->getContent();
alt.words.push_back(w);
}
el = el->getNextSibling();
}
_alternatives[alt.to] = alt;
}
return _alternatives;
}
BOOL DialogModuleInterpNormal::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: この位置に初期化の補足処理を追加してください
NormalInterpolatorNode *interp;
char *selectString = NULL;
SendDlgItemMessage(IDC_NODE_NAME, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0L);
for (interp = GetWorld()->getSceneGraph()->findNormalInterpolatorNode(); interp; interp=interp->nextTraversal()) {
if (interp && StringLength(interp->getName()) && StringNCompare(interp->getName(), CTB_NODE_NAME, strlen(CTB_NODE_NAME)))
SendDlgItemMessage(IDC_NODE_NAME, CB_ADDSTRING, 0, (LONG)(LPSTR)interp->getName());
if (!selectString)
selectString = interp->getName();
}
Node *node = getNode();
if (node)
SendDlgItemMessage(IDC_NODE_NAME, CB_SELECTSTRING,(WPARAM)-1, (LPARAM)(LPCSTR)node->getName());
else if (selectString)
SendDlgItemMessage(IDC_NODE_NAME, CB_SELECTSTRING,(WPARAM)-1, (LPARAM)(LPCSTR)selectString);
return TRUE; // コントロールにフォーカスを設定しないとき、戻り値は TRUE となります
// 例外: OCX プロパティ ページの戻り値は FALSE となります
}
QVariant Model::data(const QModelIndex &index, int role) const
{
int column(index.column());
if (!index.isValid())
return QVariant();
Node *node = static_cast<Node*>(index.internalPointer());
switch (role) {
case Qt::DisplayRole:
if (column == 0)
return node->getName();
else if (column == 1)
return node->getLineData();
else if (column == 2)
return node->getBranchData();
else if (column == 3)
return QString(QLatin1String("%1/%2")).arg(
node->getLineHitCount()).arg(node->getLineCount());
break;
case Qt::DecorationRole:
if (column == 0)
return node->getIcon();
break;
case Qt::UserRole:
if (node->isFileNode())
return node->getFullAbsoluteName();
break;
}
return QVariant();
}
int MtpStorage::getObjectInfo(MtpObjectHandle handle, MtpObjectInfo& info) {
struct stat st;
uint64_t size = 0;
MTPD("MtpStorage::getObjectInfo, handle: %u\n", handle);
Node* node = findNode(handle);
if (!node) {
// Item is not on this storage device
return -1;
}
info.mStorageID = getStorageID();
MTPD("info.mStorageID: %u\n", info.mStorageID);
info.mParent = node->getMtpParentId();
MTPD("mParent: %u\n", info.mParent);
// TODO: do we want to lstat again here, or read from the node properties?
if (lstat(getNodePath(node).c_str(), &st) == 0)
size = st.st_size;
MTPD("size is: %llu\n", size);
info.mCompressedSize = (size > 0xFFFFFFFFLL ? 0xFFFFFFFF : size);
info.mDateModified = st.st_mtime;
if (S_ISDIR(st.st_mode)) {
info.mFormat = MTP_FORMAT_ASSOCIATION;
}
else {
info.mFormat = MTP_FORMAT_UNDEFINED;
}
info.mName = strdup(node->getName().c_str());
MTPD("MtpStorage::getObjectInfo found, Exiting getObjectInfo()\n");
return 0;
}
void scObjectMgr::processScene(SceneManager *sceneMgr) {
//iterate through the Nodes
SceneNode *scRootNode = sceneMgr->getRootSceneNode();
Node::ChildNodeIterator itSceneObject = scRootNode->getChildIterator();
while(itSceneObject.hasMoreElements()) {
//get Node
Node *node = itSceneObject.getNext();
//get the Name
String scObjectName = node->getName();
if(StringUtil::startsWith(scObjectName, "pho_")) {
//create Physics
Entity *ent = sceneMgr->getEntity(scObjectName);
Vector3 pos = node->getPosition();
Quaternion rot = node->getOrientation();
BtOgre::StaticMeshToShapeConverter conv(ent);
btCollisionShape *shape = conv.createTrimesh();
btDefaultMotionState *state = new btDefaultMotionState(btTransform(BtOgre::Convert::toBullet(rot),
BtOgre::Convert::toBullet(pos)));
btRigidBody *body = new btRigidBody(0, state, shape, btVector3(0, 0, 0));
phBullet::getInstance().getWorld()->addRigidBody(body);
phBullet::getInstance().addShape(shape);
phBullet::getInstance().addBody(body);
}
}
}
//Input: index of person you want to get
//Output: string of the person at that index
//Purpose: to get the a single person in the list
std:: string Queue:: get(int index){
Node* next = first;
for ( int i = 0; i < index; i++){
next = next->getNext();
}
std:: string info = next->getName() + " ID Number: " + std::to_string( next->getIdNumber() );
return info;
}
Node * Scene::newNode(string name, Mesh * meshp, Texture * texturep) {
Node * node = new Node(name, meshp, texturep);
m_entities.push_back(node);
m_nodes.push_back(node);
m_nodeByID[node->getID()] = node;
m_nodeByName[node->getName()] = node;
return node;
}
void Tree::getTreeDotFormat(int ngen, string pn) {
ofstream out;
out.open("testdot.dbg.dot");
out << "digraph T {\n ";
out << "g [shape=record, label=\"{" << ngen << "|" << pn << "}\"]\n";
for (int i = 0; i < numNodes; i++) {
Node *p = &nodes[i];
out << " n" << p->getIdx();
out << " [shape=";
stringstream rl;
if (p->getIsLeaf()) {
rl << "{";
if (p->getAnc() == root)
rl << "anc = ROOT";
else
rl << "anc = N" << p->getAnc()->getIdx();
rl << "|R = " << setprecision(4) << p->getRateGVal() << "|";
rl << p->getName() << "}";
out << "record, label=\"" << rl.str()
<< "\", fillcolor=lightblue, style=filled]\n";
} else {
if (p == root) {
rl << "{ROOT|H = " << setprecision(4) << treeScale << "}";
out << "record, style=filled, label=\"" << rl.str() << "\"]\n";
} else {
rl << "{";
if (p->getAnc() == root)
rl << "anc = ROOT";
else
rl << "anc = N" << p->getAnc()->getIdx();
rl << "|{H = " << setprecision(5)
<< (p->getNodeDepth() * treeScale);
rl << "|R = " << setprecision(4) << p->getRateGVal() << "}|";
rl << "N" << p->getIdx() << "}";
out << "Mrecord, label=\"" << rl.str()
<< "\", fillcolor=pink, style=filled]\n";
}
}
}
for (int i = 0; i < numNodes; i++) {
Node *p = &nodes[i];
if (p->getIsLeaf() == false) {
out << " n" << p->getIdx() << " -> n" << p->getLft()->getIdx();
out << " [label=\"" << setprecision(4)
<< p->getLft()->getBranchTime() * treeScale << "\"]\n";
out << " n" << p->getIdx() << " -> n" << p->getRht()->getIdx();
out << " [label=\"" << setprecision(4)
<< p->getRht()->getBranchTime() * treeScale << "\"]\n";
}
}
out << " {rank=same;";
for (int i = 0; i < numTaxa; i++)
out << " n" << i << ";";
out << "}\n";
out << "}\n";
out.close();
}
//Input: nothing
//Output: string of the queue
//Purpose: to get the content of the whole queue
std:: string Queue:: toString(){
std:: string content;
Node* next = first;
for ( int i = 0; i < size; i++){
content += next->getName() + " ID Number: " + std::to_string( next->getIdNumber() ) + ", ";
next = next->getNext();
}
return content;
}
void TestTimelineNodeLoadedCallback::nodeLoadedCallback(cocos2d::Ref *sender)
{
Node* node = static_cast<Node*>(sender);
if (node)
{
CCLOG("node name = %s", node->getName().c_str());
CCLOG("node parent name = %s", node->getParent()->getName().c_str());
}
}
QVariant SceneGraphModel::data(const QModelIndex& parent, int role) const
{
if(role == Qt::DisplayRole)
{
Node* n = getNode(parent);
if(n != 0) return QVariant(n->getName());
}
return QVariant();
}
void PNP::addInterrupt(Place *pi, string condition, Place *po) {
Node *pe = next(next(pi)); // exec place
string ae=pe->getName();
std::size_t pos = ae.find("."); // position of "." in str
std::string a = ae.substr(0,pos);
Transition *ts = addTransition(a+".interrupt ["+condition+"]");
ts->setY(pe->getY()-1); ts->setX(pe->getX()); // upper line wrt pe
connect(pe,ts); connect(ts,po);
}
void Tree::clone(const Tree &t) {
if (numNodes != t.numNodes || numTaxa != t.numTaxa) {
cerr << "ERROR: Attempting to clone trees of unequal size" << endl;
exit(1);
}
for (int i = 0; i < numNodes; i++) {
Node *pTo = &nodes[i];
Node *pFrom = &t.nodes[i];
pTo->setName(pFrom->getName());
pTo->setNodeDepth(pFrom->getNodeDepth());
pTo->setIsLeaf(pFrom->getIsLeaf());
pTo->setRtGrpVal(pFrom->getRateGVal());
pTo->setBranchTime(pFrom->getBranchTime());
pTo->setIsCalibratedDepth(pFrom->getIsCalibratedDepth());
pTo->setNodeYngTime(pFrom->getNodeYngTime());
pTo->setNodeOldTime(pFrom->getNodeOldTime());
pTo->setRtGrpIdx(pFrom->getRateGrpIdx());
pTo->setNodeCalibPrDist(pFrom->getNodeCalibPrDist());
pTo->setNumDecendantTax(pFrom->getNumDecendantTax());
pTo->setNodeExpCalRate(pFrom->getNodeExpCalRate());
if (pFrom->getLft() == NULL)
pTo->setLft(NULL);
else
pTo->setLft(&nodes[pFrom->getLft()->getIdx()]);
if (pFrom->getRht() == NULL)
pTo->setRht(NULL);
else
pTo->setRht(&nodes[pFrom->getRht()->getIdx()]);
if (pFrom->getAnc() == NULL)
pTo->setAnc(NULL);
else
pTo->setAnc(&nodes[pFrom->getAnc()->getIdx()]);
if (pTo->getAnc() != NULL) {
noderec *pllFrom = pFrom->getPllNode();
noderec *pllTo = pTo->getPllNode();
for (int i=0; i<3; i++) {
pllTo->x = pllFrom->x;
pllTo = pllTo->next;
pllFrom = pllFrom->next;
}
}
}
root = &nodes[t.root->getIdx()];
treeScale = t.treeScale;
treeTimePrior = t.treeTimePrior;
for (int i = 0; i < numNodes; i++)
downPassSequence[i] = &nodes[t.downPassSequence[i]->getIdx()];
}
void CallGraph::addFunction(IFunction* func) {
if (nameToNode.find(func->getMangledName()) == nameToNode.end()) {
Node* n = new InstNode(this, func);
nameToNode.insert(pair<string,Node*>(n->getName(),n));
mapNameToNodeStack::iterator i = tmpCalls.find(n->getName());
if (i != tmpCalls.end()) {
stack<Node*>* s = i->second;
while (!s->empty()) {
n->addIncoming(s->top());
s->pop();
}
tmpCalls.erase(n->getName());
}
}
}
std::string Debug::Detail::ToString(const Node& node, uint32_t level) {
std::stringstream stream;
stream << "Node {" << std::endl
<< Debug::indent(level + 1) << "Name: \"" << node.getName() << "\"" << std::endl
<< Debug::indent(level + 1) << "Position: " << node.getPosition() << std::endl
<< Debug::Detail::ToStringNodeChilds(node, level + 1)
<< Debug::indent(level) << "}"
;
return stream.str();
}
/** The 'apply' method for 'node' type instances.
* we will print different information concerning the node
* Compare the 'searchForName' data member against the node's name.
* If the strings match, add this node to our list
* @param searchNode : Node : node that is searched
*/
void lgNodeOverseer::apply(Node &searchNode)
{
cout << spaces() << "Node simple : " << searchNode.getName() << endl;
// If no node is found, return searchNode
if (searchForName == "")
{
foundNodeList.push_back(&searchNode);
}
else
{
if (searchNode.getName() == searchForName)
{
foundNodeList.push_back(&searchNode);
}
_level++;
traverse(searchNode);
_level--;
}
}
bool Config::_cmdCheckFrame( co::ICommand& cmd )
{
const int64_t lastInterval = getServer()->getTime() - _lastCheck;
_lastCheck = getServer()->getTime();
co::ObjectICommand command( cmd );
LBVERB << "Check nodes for frame finish " << command << std::endl;
const uint32_t frameNumber = command.read< uint32_t >();
const uint32_t timeout = getTimeout();
bool retry = false;
const Nodes& nodes = getNodes();
for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i )
{
Node* node = *i;
if( node->isRunning() && node->isActive() )
{
co::NodePtr netNode = node->getNode();
if ( netNode->isClosed() )
continue;
if ( node->getFinishedFrame() >= frameNumber )
continue;
const int64_t interval = getServer()->getTime() -
netNode->getLastReceiveTime();
getLocalNode()->ping( netNode );
// TODO?: handle timed out nodes.
// currently we get a false positive due to lack of communication
// from client to server. we do not get ping responses in time.
// running clients should inform the server about their status with
// a timeout/2 period.
if ( interval > timeout && lastInterval <= timeout )
continue;
// retry
LBINFO << "Retry waiting for node " << node->getName()
<< " to finish frame " << frameNumber << " last seen "
<< interval << " ms ago" << " last run " << lastInterval
<< std::endl;
retry = true;
// else node timeout
}
}
if( retry )
return true;
send( command.getRemoteNode(), fabric::CMD_CONFIG_FRAME_FINISH )
<< _currentFrame;
return true;
}
/** Add an entry to a list of port entries. */
void addPort(PortTable & ports, Node p, bool param)
{
Errpos ep = p->getPos();
switch (p->kind())
{
case DEC_NODE:
if (p->isPort())
{
string name = p->getNameString();
PortKind portDir = p->getPortKind();
ports.insert(make_pair(name, Entry(param, portDir, ep)));
}
break;
case INSTANCE_NODE:
{
List args = p->getArgList();
Node name = p->getName();
Node def = name->getDefinition();
Node val = def->getValue();
List params = val->getParamList();
ListIter ita = args.begin();
ListIter itp = params.begin();
while (ita != args.end() && itp != params.end())
{
if ((*ita)->kind() == NAME_NODE)
{
string name = (*ita)->getNameString();
if ((*itp)->kind() == DEC_NODE && (*itp)->isPort())
{
PortKind portDir = (*itp)->getPortKind();
switch (portDir)
{
case SERVER:
++(ports[name].numServers);
break;
case CLIENT:
++(ports[name].numClients);
break;
}
}
else
ports[name].valid = false;
}
++ita;
++itp;
}
}
break;
default:
Error() << "Internal error: strange declaration in InstanceNode.\n" << REPORT;
break;
}
}
// for command "CANCEL [name]"
void File::cancel_name(string text)
{
// extract name in text
string name = getName(text);
// search for the node to be deleted
Node* node = BST_name->find(name);
Node* root = BST_name->getRoot();
// return if node do not exists
if(!node) {
cout << "Do not exists!" << endl << endl;
return;
}
// pop a node in queue if reservatio status is 'confirm'
if(!Queue_wait->isEmpty()) queueSize--;
if(!node->reserved()) {
Queue_wait->remove(node);
}
else {
Node* queueNode = Queue_wait->pop();
if(queueNode) queueNode->setReserved();
}
// print result
print_separator();
outputStream << node->getName() << "\t"
<< node->getPhoneNum() << "\t\t"
<< node->getId() << "\t\t\t"
<< "cancel" << endl << endl;
cout << node->getName() << "\t"
<< node->getPhoneNum() << "\t\t"
<< node->getId() << "\t\t\t"
<< "cancel" << endl << endl;
treeSize--;
BST_name->remove(root, node->getName(), false);
BST_phoneNum->remove(root, node->getPhoneNum(), false);
BST_id->remove(root, node->getId(), true);
}
//!
//! Process hover enter events.
//!
void ConnectionGraphicsItem::hoverEnterEvent ( QGraphicsSceneHoverEvent *event )
{
m_hovered = true;
if (m_connection) {
Parameter *sourceParameter = m_connection->getSourceParameter();
Parameter *targetParameter = m_connection->getTargetParameter();
if (sourceParameter && targetParameter) {
Node *sourceNode = sourceParameter->getNode();
Node *targetNode = targetParameter->getNode();
if (sourceNode && targetNode) {
QString sourceNodeName = sourceNode->getName();
QString targetNodeName = targetNode->getName();
QString sourceParameterName = sourceParameter->getName();
QString targetParameterName = targetParameter->getName();
setToolTip(sourceNodeName + "." + sourceParameterName + " --> " + targetNodeName + "." + targetParameterName);
}
}
}
update();
}
