void TreeCommon::SplitNodeOnce(int node_id) {
CNode* node = this->GetNode(node_id);
if (node == NULL || node->type() != CNode::BRANCH) {
cout << "Error Split Node: " << node_id << endl;
return;
}
CBranch* branch = (CBranch*)node;
bool is_children_all_leaf = true;
for (int i = 0; i < branch->linked_nodes.size(); ++i)
if (branch->linked_nodes[i]->type() != CNode::LEAF) {
is_children_all_leaf = false;
break;
}
if (is_children_all_leaf && branch->linked_nodes.size() > 2) {
SplitNode(branch);
vector<vector<float>> center_pos;
for (int i = 0; i < branch->linked_nodes.size(); ++i)
center_pos.push_back(branch->linked_nodes[i]->center_pos);
branch->average_dis = Utility::GetAverageDistance(center_pos);
if (branch->level() + 1 > this->max_level_) this->max_level_ = branch->level() + 1;
for (int i = 0; i < branch->linked_nodes.size(); ++i) {
id_node_map_.insert(map<int, CNode*>::value_type(branch->linked_nodes[i]->id(), branch->linked_nodes[i]));
}
}
}
void MyApplication::useSimpleArray()
{
const SceneManagerPtr& scene = BaseApplication::getSceneManager();
scene->clear();
for (s32 col = -2; col < 3; ++col)
{
for (s32 row = -2; row < 3; ++row)
{
for (s32 width = 0; width < 1; ++width)
{
CShape* model = scene->addCube(0, Vector3D((f32)row, (f32)col, -5));
if (model)
{
model->setName("cube_" + std::to_string(col) + "_" + std::to_string(row));
model->setScale(Vector3D(0.5f));
model->setRenderTechnique("shaders/default.xml");
model->getMaterial()->setTexture(0, "textures/box.jpg");
}
}
}
}
CNode* fpsCamera = scene->addFPSCamera(0, Vector3D(0, 0, 0), Vector3D(0.7f, 0, 0.7f));
fpsCamera->setName("fpsCamera");
CNode* camera = scene->addCamera(0, Vector3D(0, 0, 0), Vector3D(0.0f, 0, -5.0f));
camera->setName("camera");
scene->init();
}
CFormulaNode* CFormulaNode::getFormulaDeepFormulaChild( long frame_idx, long child_idx )
{
CNode *ret = getFormulaDeepChild( frame_idx, child_idx );
if( !ret || ret->GetType() != NODE_FORMULA )
return NULL;
return (CFormulaNode*) ret;
}
HydraIRCPlugin::~HydraIRCPlugin( void )
{
#ifdef DEBUG
OutputDebugString("HydraIRCPlugin::~HydraIRCPlugin() Called for ");
OutputDebugString(m_Name ? m_Name : "Uninitialised Plugin");
OutputDebugString("\n");
#endif
CNode *pNode;
APIDescriptor_t *APID;
while (!m_APIList.IsEmpty())
{
pNode = m_APIList.GetFirst();
APID = (APIDescriptor_t *)pNode->m_Data;
if (APID->m_Type == PLUGIN_PROVIDES && APID->m_pTable)
free(APID->m_pTable);
free(APID);
pNode->Remove();
delete pNode;
}
m_Name = NULL;
}
void DeleteRecord(CList&TelList)
{
CNode *pLook;
char szName[20];
cout<<"请输入您需要删除的姓名（输入0退出，并进入系统菜单）"<<endl;
cin.getline(szName,20);
while(strcmp(szName,"0"))
{
CTelRecord tel(szName,"0");
pLook=TelList.LookUp(tel);
if (pLook)
{
cout<<"在电话簿中找到"<<szName<<",内容是："<<endl;
pLook->ShowNode();
cout<<"请确定是否删除此记录（Y/N)【确定删除请输入Y或y,取消删除请输入N或n】:"<<endl;
char ok;
cin>>ok;
cin.ignore();
if (ok=='Y'||ok=='y')
{
TelList.DeleteNode(pLook);
cout<<szName<<"的资料删除成功！"<<endl;
delete pLook;
count--;
}
else if(ok=='N'||ok=='n')
cout<<szName<<"的资料删除失败"<<endl;
}
else
cout<<"在电话簿中找不到"<<szName<<","<<endl;
cout<<"请输入您需要删除的姓名（输入0退出，并进入系统菜单）"<<endl;
cin.getline(szName,20);
}
//---------------------------------------------------------------------------
// @function:
// CTreeMapTest::EresUnittest_Unrank
//
// @doc:
// Rehydrate all trees encoded in the map
//
//---------------------------------------------------------------------------
GPOS_RESULT
CTreeMapTest::EresUnittest_Unrank()
{
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
TestMap *ptmap = PtmapLoad(pmp);
// debug print
CWStringDynamic str(pmp);
COstreamString oss(&str);
ULLONG ullCount = ptmap->UllCount();
for (ULONG ulRank = 0; ulRank < ullCount; ulRank++)
{
oss << "=== tree rank: " << ulRank << " ===" << std::endl;
BOOL fFlag = true;
CNode *pnd = ptmap->PrUnrank(pmp, &fFlag, ulRank);
(void) pnd->OsPrint(oss);
pnd->Release();
}
GPOS_TRACE(str.Wsz());
GPOS_DELETE(ptmap);
return GPOS_OK;
}
//=============================================================================
void CGraph::EdgeAddDirected (INode * start, INode * end)
{
CNode * nodeStart = CNode::From(start);
CNode * nodeEnd = CNode::From(end);
nodeStart->AddNeighbor(nodeEnd);
}
//***********************************************************************************************
CParticleWorkspace::CNode *CParticleWorkspace::addNode(const std::string &filenameWithFullPath) throw( NLMISC::EStream)
{
nlassert(_OV);
// Check that file is not already inserted
std::string fileName = NLMISC::CFile::getFilename(filenameWithFullPath);
for(uint k = 0; k < _Nodes.size(); ++k)
{
if (NLMISC::nlstricmp(_Nodes[k]->getFilename(), fileName) == 0) return NULL;
}
char resultPath[MAX_PATH];
std::string dosPath = NLMISC::CPath::standardizeDosPath(getPath());
std::string relativePath;
if (!PathRelativePathTo(resultPath, dosPath.c_str(), FILE_ATTRIBUTE_DIRECTORY, filenameWithFullPath.c_str(), 0))
{
relativePath = filenameWithFullPath;
}
else
{
relativePath = resultPath;
}
if (relativePath.size() >= 2)
{
if (relativePath[0] == '\\' && relativePath[1] != '\\')
{
relativePath = relativePath.substr(1);
}
}
CNode *newNode = new CNode;
newNode->init(this);
newNode->setRelativePath(relativePath);
_Nodes.push_back(newNode);
setModifiedFlag(true);
return newNode;
}
void MyApplication::useInstancedObject()
{
const SceneManagerPtr& scene = BaseApplication::getSceneManager();
scene->clear();
CShape* model = scene->addCube(0, Vector3D(0, 0, -5));
if (model)
{
model->setName("cube");
model->setScale(Vector3D(0.5f));
model->setRenderTechnique("shaders/default_instancing.xml");
model->getMaterial()->setTexture(0, "textures/box.jpg");
const RenderPassPtr& pass = model->getRenderTechique()->getRenderPass(0);
u32 index = 0;
for (s32 col = -2; col < 3; ++col)
{
for (s32 row = -2; row < 3; ++row)
{
for (s32 width = 0; width < 1; ++width)
{
pass->getUserShaderData()->setUniform("offsets[" + std::to_string(index) + "]", Vector3D((f32)col, (f32)row, f32(- 5 - width)));
++index;
}
}
}
}
CNode* fpsCamera = scene->addFPSCamera(0, Vector3D(0, 0, 0), Vector3D(0.7f, 0, 0.7f));
fpsCamera->setName("fpsCamera");
CNode* camera = scene->addCamera(0, Vector3D(0, 0, 0), Vector3D(0.0f, 0, -5.0f));
camera->setName("camera");
scene->init();
}
CNode* CMigrationInfo::FindNodeWithFreeMem(CNode* i_sourceNode, CProcess* i_process)
{
i_sourceNode->WriteLog("MIGRATION - MEM ISSUES - Searching for destination node to establish migration");
CNode* returnValue = NULL;
bool found = false;
double maxFreeMem = 0;
uint32_t maxIndex = 0;
// find out which is the process with the greatest free mem that we can migrate to:
if (i_sourceNode->GetAvailableBandwidth() > 0)
{
for (uint32_t i = 0; i < CMasterSingleton::GetInstance()->GetNodeCount(); ++i)
{
CNode* currentNode = CMasterSingleton::GetInstance()->GetNode(i);
double freeMem = currentNode->GetFreeMem();
if (maxFreeMem < freeMem && i_sourceNode->GetId() != currentNode->GetId() && CanBeDestination(currentNode, i_process))
{
maxFreeMem = freeMem;
maxIndex = i;
found = true;
}
}
// if found is false, we will return a null pointer meaning that the migration should not happen
if (found)
returnValue = CMasterSingleton::GetInstance()->GetNode(maxIndex);
}
return returnValue;
}
void CControl::Initialize()
{
super::Initialize();
m_bUninitialize = false;
if ( strcmp( m_strName.c_str(), DEFAULT_CONTROL_NAME ) == 0)
{
SetName( GetDefaultName() );
}
else
{
CWindowManager::GetInstance()->RegisterControl( this );
}
CalcInheritColor();
CRenderTarget* pMainRenderTarget = CRenderManager::GetInstance()->GetCurrentRenderTarget();
BEATS_ASSERT( pMainRenderTarget );
CNode* pParentNode = GetParentNode();
if ( nullptr == pParentNode)
{
CWindowManager::GetInstance()->AddToRoot( this );
}
if (nullptr == pParentNode || pParentNode->GetType() != eNT_NodeGUI )
{
//update control vertex by render target
OnParentSizeChange( (float)pMainRenderTarget->GetWidth(), (float)pMainRenderTarget->GetHeight());
}
}
void CNet::locktree (void)
{
CNode *node;
for (node = rtree; node != NULL; node = node->data.rtree) node->lock ();
}
CNode* CMigrationInfo::FindNodeWithFreeCpu(CNode* i_sourceNode, CProcess* i_process)
{
i_sourceNode->WriteLog("MIGRATION - CPU ISSUES - Searching for destination node to establish migration");
CNode* returnValue = NULL;
bool found = false;
uint32_t minIndex = 0;
double minCpu = 1;
if (i_sourceNode->GetAvailableBandwidth() > 0)
{
for (uint32_t i = 0; i < CMasterSingleton::GetInstance()->GetNodeCount(); ++i)
{
CNode* currentNode = CMasterSingleton::GetInstance()->GetNode(i);
double cpuUsage = currentNode->GetCpuUsage();
if (minCpu > cpuUsage && i_sourceNode->GetId() != currentNode->GetId() && CanBeDestination(currentNode, i_process))
{
minCpu = cpuUsage;
minIndex = i;
found = true;
}
}
// if found is false, we will return a null pointer meaning that the migration should not happen
if (found)
returnValue = CMasterSingleton::GetInstance()->GetNode(minIndex);
}
return returnValue;
}
void CParentNode::RemoveOrCopyChildren( QVector<CNode*> &children, long nFrom, long nTo, int fRemove )
{
if( nTo == -1 ) nTo = (long) m_children.size();
Q_ASSERT( nTo <= (long) m_children.size() );
Q_ASSERT( nTo >= nFrom );
children.resize( nTo - nFrom );
if( children.size() )
{
for( long i = 0; i < (long) children.size(); i++ )
{
children[ i ] = (fRemove ? m_children[ nFrom + i ] : CreateCopy( m_children[ nFrom + i ] ) );
children[ i ]->SetParent( NULL );
}
children[ 0 ]->SetPrev( NULL );
children[ children.size() - 1 ]->SetNext( NULL );
if( fRemove )
{
m_children.remove( nFrom, nTo - nFrom );
CNode *pPrev = (nFrom - 1 > -1 && nFrom - 1 < (long) m_children.size()) ? m_children[ nFrom - 1 ] : NULL;
CNode *pNext = (nFrom > -1 && nFrom < (long) m_children.size()) ? m_children[ nFrom ] : NULL;
if( pPrev ) pPrev->SetNext( pNext );
if( pNext ) pNext->SetPrev( pPrev );
}
}
}
// execute
void CGenericXmlMsgHeaderManager::execute(CBitMemStream &strm)
{
// check root
if (_Root == NULL)
{
nlwarning("Can't execute message , Root not properly initialized.");
return;
}
CNode *node = _Root->select(strm);
// check node
if (node == NULL)
{
nlwarning("Can't execute stream, no valid sequence found");
}
// check callback
else if (node->Callback == NULL)
{
nlwarning("Can't execute msg '%s', no callback set", node->Name.c_str());
}
// execute callback
else
{
node->Callback(strm);
}
}
CFormulaNode* CFormulaNode::getSemanticsOrCTokenNodeWrapped()
{
for( CNode *curNode = this; curNode != 0; curNode = curNode->GetParent() )
{
if( curNode->GetType() == NODE_FORMULA && curNode->to_mathml_data.is_content != 0 )
{
if( !xml_strcmp( curNode->to_mathml_data.name, FBL_TAG_semantics ) ||
!xml_strcmp( curNode->to_mathml_data.name, FBL_TAG_annotation ) ||
::mml_is_cm_token( curNode->to_mathml_data.name ) )
return (CFormulaNode*)curNode;
else if( curNode->to_mathml_data.name == FBL_TAG_annotation_xml )
{
QString attrValue = _T("");
struct HMathMLAttr mml_attr_by_this_node( getMathMLAttr() );
if( mml_attr_by_this_node.getFilteredAttr( FBL_ATTR_encoding, attrValue ) == 0 &&
attrValue == FBL_VAL_MathML_Content )
{
continue;
}
return (CFormulaNode*)curNode;
}
}
}
return 0;
}
bool MessageParser::parse(CNode& post)
{
// parse author
CSelection author = post.find("span.name > strong");
if (author.nodeNum() < 1)
return false;
rawMessage.author=author.nodeAt(0).text();
// parse message
CSelection message = post.find(".postbody > div");
if (message.nodeNum() < 1)
return false;
rawMessage.content = message.nodeAt(0).text();
// parse date
// TODO(arthur)
CSelection date= post.find(".postdetails");
if (date.nodeNum() >= 2)
if (date.nodeAt(1).childNum() >= 4)
{
rawMessage.date.fromString(
date.nodeAt(1).childAt(3).text());
}
return true;
}
void CLineNode::InsertMML_CM_apply__read_op(
AST_TXML_Tag *_item_node, QString _item_str, int readonly, long form )
{
if( _item_node )
{
CLineNode *lbuf = new CLineNode();
lbuf->read_mathml( _item_node );
if( readonly )
lbuf->iterateNodeTree( setRecursiveReadOnly_n_IgnoreContent, 0 );
else if( form == __APPLY_RENDER_FORM_OP )
{
CNode *pNode = lbuf->GetFirstChild();
while( pNode )
{
pNode->to_mathml_data.is_content =
CONTENT_MATHML_CONVERTION2__APPLY_OPERATOR_RECURSIVE_TREE;
pNode = pNode->GetNext();
}
}
PumpLine2Line( lbuf );
delete lbuf;
}
else if( _item_str.length() )
InsertMML_CM_create_markup_rigid_token( FBL_TAG_mo, _item_str );
}
/**
* Performs some local preprocessing of the given @a trace which is required
* to provide the full trace-access functionality. This has to be done as the
* last step in setting up the data structures, i.e., after calling
* PEARL_verify_calltree() and PEARL_mpi_unify_calltree().
*
* @note This function is intended to be used in single-threaded PEARL
* programs, i.e., serial or pure MPI.
*
* @param defs Global definitions object
* @param trace Local trace data object
*
* @see PEARL_omp_preprocess_trace(), PEARL_verify_calltree(),
* PEARL_mpi_unify_calltree()
*/
void pearl::PEARL_preprocess_trace(const GlobalDefs& defs,
const LocalTrace& trace)
{
// Precompute CNODE pointers
Calltree* ctree = defs.get_calltree();
CNode* current = NULL;
Event event = trace.begin();
while (event != trace.end()) {
// Enter event
if (event->is_typeof(ENTER))
{
Enter_rep* enter = dynamic_cast<Enter_rep*>(event.operator->());
current = ctree->add_cnode(enter->get_regionEntered(),
enter->get_callsite(),
current, enter->get_time());
enter->set_cnode(current);
}
// Exit event
else if (event->is_typeof(EXIT))
{
current = current->get_parent();
}
++event;
}
}
CFormulaNode* CLineNode::InsertMMLFormulaNode_OTHERS( FXmlBtn *ptrFXmlBtn, AST_TXML_Compound *node, int is_hidden )
{
CFormulaNode *new_node = 0;
CFrameNode *pFrameNode = 0;
CNode *pCurNode = 0;
if( !ptrFXmlBtn )
return NULL; // error: Internal error
if( ptrFXmlBtn->getNodeType() == NODE_FORMULA )
{
new_node = CreateFormulaNode( *ptrFXmlBtn );
if( !new_node ) return NULL; // error: Internal error
pFrameNode = (CFrameNode *)GetFrameNode();
if( pFrameNode ) new_node->SetLevel( pFrameNode->GetLevel() );
AddChild( new_node );
if( node )
{
pCurNode = new_node->GetFirstChild();
if( pCurNode && pCurNode->GetType() == NODE_FRAME )
{
if( ((CFrameNode*)pCurNode)->GetFirstChild() )
((CFrameNode*)pCurNode)->DeleteChild( ((CFrameNode*)pCurNode)->GetFirstChild() );
pCurNode->read_mathml( node );
}
}
}
if( new_node && is_hidden )
new_node->setHidden();
return new_node;
}
CNode* DepthFirstStrategy::GetNextNode()
{
if(nodeStack.empty())
return NULL;
if(last == NULL)
{
last = nodeStack.back();
return nodeStack.back();
}
else
{
nodeStack.pop_back();
for(unsigned int i=0; i<last->children.size(); i++)
{
CNode* child = last->children[i];
if(child->IsNodeInteresting())
{
nodeStack.push_back(child);
}
}
if(nodeStack.empty())
return NULL;
last = nodeStack.back();
return nodeStack.back();
}
}
bool CDoubleLinkedList::addNode( CNodeObject * pObject )
{
int nsearchResult = 0;
CNode * pNode = m_pHead;
if ( m_nSort == SORT_NONE ) {
// No sorting just add as last element
addNodeTail( pObject );
return true;
}
if ( ( m_nSort == SORT_STRING ) && ( NULL == pObject->m_pstrSortKey ) ) {
return false;
}
if ( ( m_nSort == SORT_NUMERIC ) && ( NULL == pObject->m_pKey ) ) {
return false;
}
if ( NULL != pNode ) {
while (pNode != NULL ) {
if ( ( m_nSort == SORT_STRING ) && ( NULL != pObject->m_pstrSortKey ) ) {
nsearchResult = strcmp( pNode->getObject()->m_pstrSortKey,
pObject->m_pstrSortKey );
}
else if ( ( m_nSort == SORT_NUMERIC ) ) {
if ( *pObject->m_pKey == *pNode->getObject()->m_pKey ) {
nsearchResult = 0;
}
else if ( *pObject->m_pKey > *pNode->getObject()->m_pKey ) {
nsearchResult = 2;
}
else {
nsearchResult = -1;
}
}
if ( 0 == nsearchResult ) {
// Entry already in table - Not allowed
return false;
}
else if ( nsearchResult > 0 ) {
// Add before current item
addNodeBefore( pNode, pObject );
return true;
}
pNode = pNode->getNextNode();
}
}
else {
// Add to tail - last id
addNodeTail( pObject );
}
return true;
}
//=============================================================================
void CGraph::EdgeAddSymetric (INode * a, INode * b)
{
CNode * nodeA = CNode::From(a);
CNode * nodeB = CNode::From(b);
nodeA->AddNeighbor(nodeB);
nodeB->AddNeighbor(nodeA);
}
//check node value is float
void CTagCn::nodeIsReal(const CNode& node)const
{
size_t pos = 0;
string num = deleteSpaces(node.text().as_string());
double d = stod(num, &pos);
if (pos != num.length() || !num.length())
throwException(node, node.offset_debug(), INCORRECT_VALUE);
}
void CanonicalizeVisitor::VisitNextCNode(CNode* s) {
CNode* next = s->GetNextCNode();
if (next) {
next->Accept(*this);
} else {
FinishBB();
}
}
void test_escape() {
std::string page = "<html><div><span id=\"that's\">1\n</span>2\n</div></html>";
CDocument doc;
doc.parse(page.c_str());
CNode pNode = doc.find("span[id=\"that's\"]").nodeAt(0);
std::string content = page.substr(pNode.startPos(), pNode.endPos() - pNode.startPos());
printf("Node: #%s#\n", content.c_str());
}
unsigned int __stdcall CDeviceView::RefreshThread(void *Param)
{
RefreshThreadData *ThreadData = (RefreshThreadData *)Param;
CDeviceView *This = ThreadData->This;
// Get a copy of the currently selected node
CNode *LastSelectedNode = This->GetSelectedNode();
if (LastSelectedNode == nullptr || (LastSelectedNode->GetNodeType() == RootNode))
{
LastSelectedNode = new CRootNode(*This->m_RootNode);
}
else if (LastSelectedNode->GetNodeType() == ClassNode)
{
LastSelectedNode = new CClassNode(*dynamic_cast<CClassNode *>(LastSelectedNode));
}
else if (LastSelectedNode->GetNodeType() == DeviceNode)
{
LastSelectedNode = new CDeviceNode(*dynamic_cast<CDeviceNode *>(LastSelectedNode));
}
// Empty the treeview
This->EmptyDeviceView();
// Re-add the root node to the tree
if (This->AddRootDevice() == false)
return 0;
// Refresh the devices only if requested
if (ThreadData->ScanForChanges)
{
This->RefreshDeviceList();
}
// display the type of view the user wants
switch (This->m_ViewType)
{
case DevicesByType:
(void)This->ListDevicesByType();
break;
case DevicesByConnection:
(VOID)This->ListDevicesByConnection();
break;
case ResourcesByType:
break;
case ResourcesByConnection:
break;
}
This->SelectNode(LastSelectedNode);
delete ThreadData;
return 0;
}
void EDGAR_FilingFile::FindEDGAR_Tables(RunMode run_mode)
{
// always start fresh
EDGAR_filing_tables_.clear();
CDocument the_filing;
the_filing.parse(EDGAR_filing_content_.c_str());
CSelection c = the_filing.find("table");
// ConvertMarkupToText is a time consuming function -- it actually calls out to
// an external process right now -- so let's do some async'ing !!
// keep track of our async processes here.
std::vector<std::future<std::string>> tasks;
for (int indx = 0 ; indx < c.nodeNum(); ++indx)
{
CNode pNode = c.nodeAt(indx);
// use the 'Outer' functions to include the table tags in the extracted content.
std::string content = EDGAR_filing_content_.substr(pNode.startPosOuter(), pNode.endPosOuter() - pNode.startPosOuter());
if (TableHasMarkup(content))
{
if (run_mode == RunMode::do_sync)
{
std::string plain_table = ConvertMarkupToText(content);
EDGAR_filing_tables_.push_back(plain_table);
}
else
tasks.push_back(std::async(&EDGAR_FilingFile::ConvertMarkupToText, this, content));
}
else
EDGAR_filing_tables_.push_back(content);
}
// now, let's go look for our output...
for (int count = tasks.size(); count; --count)
{
int i = wait_for_any(tasks, std::chrono::microseconds{100});
std::string converted_text;
try
{
converted_text = tasks[i].get();
}
catch (...)
{
// any problems, let's just ignore them.
poco_error(the_logger_, "Some problem with an async process");
continue;
}
if (! converted_text.empty())
EDGAR_filing_tables_.push_back(converted_text);
}
} // ----- end of method EDGAR_FilingFile::FindEDGAR_Tables -----
void CTagQualifiers::operator()( const CNode& node, CTreeNode& tree_node )
{
(*this)(node);
auto arg = node.first_child();
CTag& argTag = CTagContainer::getTag( arg.name() );
int argType = argTag.getType();
argTag(arg, tree_node.Step(node.name()));
arg = argTag.checkSignature(arg);
}
void CControl::WorldToLocal(float &x, float &y)
{
CNode* pParent = GetParentNode();
if( pParent && pParent->GetType() == eNT_NodeGUI )
{
down_cast<CControl*>(pParent)->WorldToLocal(x, y);
}
ParentToLocal(x, y);
}
