自学教程：C++ IsNode函数代码示例

Hardware::MinorType getHardwareType(string name, HardwareType ht, const Database *const pDB) throw (Error){	xmlKeepBlanksDefault(0);	xmlDocPtr doc;	try	{		doc = xmlParseFile(pDB->getHWPath(name, ht).c_str());	}	catch (...)	{		throw;	}		if (doc == 0) throw Error("Cannot initialize XML parser");	xmlNodePtr cur = xmlDocGetRootElement(doc);	if (cur == 0)	{		xmlFreeDoc(doc);		throw Error("XML document is empty, invalid hardware file");	}	string strIFace("NA");	bool bFound = false;	cur = cur->xmlChildrenNode;	while (cur != 0 && !bFound)	{		if (IsNode(cur, "hardware"))		{			xmlNodePtr save = cur;			cur = cur->xmlChildrenNode;			while (cur != 0)			{				if (IsNode(cur, "interface"))				{					strIFace = GetVal(doc, cur);					bFound = true;					break;				}				cur = cur->next;			}			cur = save;		}		cur = cur->next;	}		xmlFreeDoc(doc);	xmlCleanupParser();	if (strIFace == "ethernet")			return Hardware::BBEth;	if (strIFace == "usb")				return Hardware::BBUSB;	if (strIFace == "usb||ethernet")	return Hardware::BBDual;	return Hardware::Unknown;}

int TNGraph::AddEdge(const int& SrcNId, const int& DstNId) {  IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId, DstNId).CStr());  //IAssert(! IsEdge(SrcNId, DstNId));  if (IsEdge(SrcNId, DstNId)) { return -2; }  GetNode(SrcNId).OutNIdV.AddSorted(DstNId);  GetNode(DstNId).InNIdV.AddSorted(SrcNId);  return -1; // edge id}

int TNGraph::AddEdge2(const int& SrcNId, const int& DstNId) {  if (! IsNode(SrcNId)) { AddNode(SrcNId); }  if (! IsNode(DstNId)) { AddNode(DstNId); }  if (GetNode(SrcNId).IsOutNId(DstNId)) { return -2; } // edge already exists  GetNode(SrcNId).OutNIdV.AddSorted(DstNId);  GetNode(DstNId).InNIdV.AddSorted(SrcNId);  return -1; // no edge id}

// Add an edge between SrcNId and DstNId to the graph.int TUNGraph::AddEdge(const int& SrcNId, const int& DstNId) {  IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId, DstNId).CStr());  if (IsEdge(SrcNId, DstNId)) { return -2; } // edge already exists  GetNode(SrcNId).NIdV.AddSorted(DstNId);  if (SrcNId!=DstNId) { // not a self edge    GetNode(DstNId).NIdV.AddSorted(SrcNId); }  return -1; // edge id}

void TMultimodalGraphImplB::DelEdge(const TPair<TInt,TInt>& SrcNId, const TPair<TInt,TInt>& DstNId) {  IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId.GetVal2(), DstNId.GetVal2()).CStr());  if (!IsEdge(SrcNId, DstNId)) {    return; // Edge doesn't exist  }  NEdges--;  TPair<TInt,TInt> ModeIdsKey = GetModeIdsKey(SrcNId.GetVal1(), DstNId.GetVal1());  Graphs.GetDat(ModeIdsKey).DelEdge(SrcNId.GetVal2(), DstNId.GetVal2());}

int TNEGraph::AddEdge(const int& SrcNId, const int& DstNId, int EId) {  if (EId == -1) { EId = MxEId;  MxEId++; }  else { MxEId = TMath::Mx(EId+1, MxEId()); }  IAssert(! IsEdge(EId));  IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId, DstNId).CStr());  EdgeH.AddDat(EId, TEdge(EId, SrcNId, DstNId));  GetNode(SrcNId).OutEIdV.AddSorted(EId);  GetNode(DstNId).InEIdV.AddSorted(EId);  return EId;}

bool TMultimodalGraphImplB::IsEdge(const TPair<TInt,TInt>& SrcNId, const TPair<TInt,TInt>& DstNId) const {  if (!IsNode(SrcNId) || !IsNode(DstNId)) return false;  TPair<TInt,TInt> ModeIdsKey = GetModeIdsKey(SrcNId.GetVal1(), DstNId.GetVal2());  if (!Graphs.IsKey(ModeIdsKey)) {    return false;  }  return Graphs.GetDat(ModeIdsKey).IsEdge(SrcNId.GetVal2(), DstNId.GetVal2());}

int TNEANetMP::AddEdge(const int& SrcNId, const int& DstNId, int EId) {    int i;    if (EId == -1) {        EId = MxEId;        MxEId++;    }    else {        MxEId = TMath::Mx(EId+1, MxEId());    }    IAssertR(!IsEdge(EId), TStr::Fmt("EdgeId %d already exists", EId));    IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId, DstNId).CStr());    EdgeH.AddDat(EId, TEdge(EId, SrcNId, DstNId));    GetNode(SrcNId).OutEIdV.AddSorted(EId);    GetNode(DstNId).InEIdV.AddSorted(EId);    // update attribute columns    for (i = 0; i < VecOfIntVecsE.Len(); i++) {        TVec<TInt>& IntVec = VecOfIntVecsE[i];        IntVec.Ins(EdgeH.GetKeyId(EId), TInt::Mn);    }    TVec<TStr> DefIntVec = TVec<TStr>();    IntDefaultsE.GetKeyV(DefIntVec);    for (i = 0; i < DefIntVec.Len(); i++) {        TStr attr = DefIntVec[i];        TVec<TInt>& IntVec = VecOfIntVecsE[KeyToIndexTypeE.GetDat(DefIntVec[i]).Val2];        IntVec[EdgeH.GetKeyId(EId)] = GetIntAttrDefaultE(attr);    }    for (i = 0; i < VecOfStrVecsE.Len(); i++) {        TVec<TStr>& StrVec = VecOfStrVecsE[i];        StrVec.Ins(EdgeH.GetKeyId(EId), TStr::GetNullStr());    }    TVec<TStr> DefStrVec = TVec<TStr>();    IntDefaultsE.GetKeyV(DefStrVec);    for (i = 0; i < DefStrVec.Len(); i++) {        TStr attr = DefStrVec[i];        TVec<TStr>& StrVec = VecOfStrVecsE[KeyToIndexTypeE.GetDat(DefStrVec[i]).Val2];        StrVec[EdgeH.GetKeyId(EId)] = GetStrAttrDefaultE(attr);    }    for (i = 0; i < VecOfFltVecsE.Len(); i++) {        TVec<TFlt>& FltVec = VecOfFltVecsE[i];        FltVec.Ins(EdgeH.GetKeyId(EId), TFlt::Mn);    }    TVec<TStr> DefFltVec = TVec<TStr>();    FltDefaultsE.GetKeyV(DefFltVec);    for (i = 0; i < DefFltVec.Len(); i++) {        TStr attr = DefFltVec[i];        TVec<TFlt>& FltVec = VecOfFltVecsE[KeyToIndexTypeE.GetDat(DefFltVec[i]).Val2];        FltVec[NodeH.GetKeyId(EId)] = GetFltAttrDefaultE(attr);    }    return EId;}

double TCascade::TransProb(const int& NId1, const int& NId2) const {	if (! IsNode(NId1) || ! IsNode(NId2)) { return Eps; }	if (GetTm(NId1) >= GetTm(NId2)) { return Eps; }	if (Model==0)		return Alpha*exp(-Alpha*(GetTm(NId2)-GetTm(NId1))); // exponential	else if (Model==1)		return (Alpha-1)*pow((GetTm(NId2)-GetTm(NId1)), -Alpha); // power-law	else		return Alpha*(GetTm(NId2)-GetTm(NId1))*exp(-0.5*Alpha*pow(GetTm(NId2)-GetTm(NId1), 2)); // rayleigh    	return (-1);}

/* markSmall: * cp corresponds to a real node. If it is small, its associated cells should * be marked as usable. */static voidmarkSmall (cell* cp, sgraph* g){    int i;    snode* onp;    cell* ocp;    if (IS_SMALL(cp->bb.UR.y-cp->bb.LL.y)) {	for (i = 0; i < cp->nsides; i++) {	    onp = cp->sides[i];	    if (!onp->isVert) continue;	    if (onp->cells[0] == cp) {  /* onp on the right of cp */		ocp = onp->cells[1];		ocp->flags |= MZ_SMALLV;		while ((onp = ocp->sides[M_RIGHT]) && !IsNode(onp->cells[1])) {		    ocp = onp->cells[1];		    ocp->flags |= MZ_SMALLV;		}	    }	    else {                      /* onp on the left of cp */		ocp = onp->cells[0];		ocp->flags |= MZ_SMALLV;		while ((onp = ocp->sides[M_LEFT]) && !IsNode(onp->cells[0])) {		    ocp = onp->cells[0];		    ocp->flags |= MZ_SMALLV;		}	    }	}    }    if (IS_SMALL(cp->bb.UR.x-cp->bb.LL.x)) {	for (i = 0; i < cp->nsides; i++) {	    onp = cp->sides[i];	    if (onp->isVert) continue;	    if (onp->cells[0] == cp) {  /* onp on the top of cp */		ocp = onp->cells[1];		ocp->flags |= MZ_SMALLH;		while ((onp = ocp->sides[M_TOP]) && !IsNode(onp->cells[1])) {		    ocp = onp->cells[1];		    ocp->flags |= MZ_SMALLH;		}	    }	    else {                      /* onp on the bottom of cp */		ocp = onp->cells[0];		ocp->flags |= MZ_SMALLH;		while ((onp = ocp->sides[M_BOTTOM]) && !IsNode(onp->cells[0])) {		    ocp = onp->cells[0];		    ocp->flags |= MZ_SMALLH;		}	    }	}    }}

bool TNEGraph::IsOk(const bool& ThrowExcept) const {bool RetVal = true;  for (int N = NodeH.FFirstKeyId(); NodeH.FNextKeyId(N); ) {    const TNode& Node = NodeH[N];    if (! Node.OutEIdV.IsSorted()) {      const TStr Msg = TStr::Fmt("Out-edge list of node %d is not sorted.", Node.GetId());      if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;    }    if (! Node.InEIdV.IsSorted()) {      const TStr Msg = TStr::Fmt("In-edge list of node %d is not sorted.", Node.GetId());      if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;    }    // check out-edge ids    int prevEId = -1;    for (int e = 0; e < Node.GetOutDeg(); e++) {      if (! IsEdge(Node.GetOutEId(e))) {        const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.",  Node.GetOutEId(e), Node.GetId());        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;      }      if (e > 0 && prevEId == Node.GetOutEId(e)) {        const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetOutEId(e));        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;      }      prevEId = Node.GetOutEId(e);    }    // check in-edge ids    prevEId = -1;    for (int e = 0; e < Node.GetInDeg(); e++) {      if (! IsEdge(Node.GetInEId(e))) {        const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.",  Node.GetInEId(e), Node.GetId());        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;      }      if (e > 0 && prevEId == Node.GetInEId(e)) {        const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetInEId(e));        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;      }      prevEId = Node.GetInEId(e);    }  }  for (int E = EdgeH.FFirstKeyId(); EdgeH.FNextKeyId(E); ) {    const TEdge& Edge = EdgeH[E];    if (! IsNode(Edge.GetSrcNId())) {      const TStr Msg = TStr::Fmt("Edge %d source node %d does not exist.", Edge.GetId(), Edge.GetSrcNId());      if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;    }    if (! IsNode(Edge.GetDstNId())) {      const TStr Msg = TStr::Fmt("Edge %d destination node %d does not exist.", Edge.GetId(), Edge.GetDstNId());      if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;    }  }  return RetVal;}

// update the cascade probability given a new edge (N1, N2) in the graphdouble TCascade::UpdateProb(const int& N1, const int& N2, const bool& UpdateProb) {    if (!IsNode(N1) || !IsNode(N2)) { return CurProb; }    if (GetTm(N1) >= GetTm(N2)) { return CurProb; }    const double P1 = log(TransProb(GetParent(N2), N2));    const double P2 = log(TransProb(N1, N2)); // N1 influences N2    if (P1 < P2) {        if (UpdateProb) { // the edge is there, update the CurProb and best Parent            CurProb = CurProb - P1 + P2;            NIdHitH.GetDat(N2).Parent = N1;        } else {            return CurProb - P1 + P2; }    }    return CurProb;}

void RestoreProps(struct xmlNode *input, PROJECTITEM *root, PROJECTITEM *parent){    while (input)    {        if (IsNode(input, "PROP"))        {            // oldformat            struct xmlAttr *attribs = input->attribs;            char *id = NULL;            while (attribs)            {                if (IsAttrib(attribs, "ID"))                    id = attribs->value;                attribs = attribs->next;            }             if (strcmp(id, "__DEBUG"))            {                PROFILE *p = parent->profiles;                while (p)                {                    if (!stricmp(p->name, "WIN32"))                    {                        break;                    }                    p = p->next;                }                if (!p)                {                    PROFILE **q = &parent->profiles;                    while (*q) q= &(*q)->next;                    *q = calloc(1, sizeof(PROFILE));                    (*q)->name = sysProfileName;                    p = *q;                    }                if (p)                {                    RestoreOneProp(input, &p->debugSettings);                    RestoreOneProp(input, &p->releaseSettings);                }            }        }        else if (IsNode(input, "PROFILE"))        {            RestoreProfileProps(input, root, parent);        }        input = input->next;    }}

static voidemitSearchGraph (FILE* fp, sgraph* sg){    cell* cp;    snode* np;    sedge* ep;    point p;    int i;    fputs ("graph G {/n", fp);    fputs (" node[shape=point]/n", fp);    for (i = 0; i < sg->nnodes; i++) {	np = sg->nodes+i;	cp = np->cells[0];	if (cp == np->cells[1]) {	    pointf pf = midPt (cp);	    p.x = pf.x;	    p.y = pf.y;	}	else {	    if (IsNode(cp)) cp = np->cells[1];	    p = coordOf (cp, np);	}	fprintf (fp, "  %d [pos=/"%d,%d/"]/n", i, p.x, p.y);    }    for (i = 0; i < sg->nedges; i++) {	ep = sg->edges+i;	fprintf (fp, "  %d -- %d[len=/"%f/"]/n", ep->v1, ep->v2, ep->weight);    }    fputs ("}/n", fp);}

int TUNGraph::AddNode(int NId) {  if (NId == -1) { NId = MxNId;  MxNId++; }  else if (IsNode(NId)) { return NId; } // already a node  else { MxNId = TMath::Mx(NId+1, MxNId()); }  NodeH.AddDat(NId, TNode(NId));  return NId;}

void RestoreGeneralProps(struct xmlNode *node, int version){    node = node->children;    while (node)    {        if (IsNode(node, "PROP"))        {            struct xmlAttr *attribs = node->attribs;            char *id = NULL;            while (attribs)            {                if (IsAttrib(attribs, "ID"))                    id = attribs->value;                attribs = attribs->next;            }             if (id)            {                SETTING *setting = PropFind(NULL, id);                if (!setting)                {                    setting = calloc(1, sizeof(SETTING));                    setting->type = e_text;                    setting->id = strdup(id);                    InsertSetting(&generalProject, setting);                }                if (setting)                {                    free(setting->value);                    setting->value = strdup(node->textData);                }            }        }         node = node->next;    }}

// Check the graph data structure for internal consistency.bool TUNGraph::IsOk(const bool& ThrowExcept) const {  bool RetVal = true;  for (int N = NodeH.FFirstKeyId(); NodeH.FNextKeyId(N); ) {    const TNode& Node = NodeH[N];    if (! Node.NIdV.IsSorted()) {      const TStr Msg = TStr::Fmt("Neighbor list of node %d is not sorted.", Node.GetId());      if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); }      RetVal=false;    }    int prevNId = -1;    for (int e = 0; e < Node.GetDeg(); e++) {      if (! IsNode(Node.GetNbrNId(e))) {        const TStr Msg = TStr::Fmt("Edge %d --> %d: node %d does not exist.",          Node.GetId(), Node.GetNbrNId(e), Node.GetNbrNId(e));        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); }        RetVal=false;      }      if (e > 0 && prevNId == Node.GetNbrNId(e)) {        const TStr Msg = TStr::Fmt("Node %d has duplicate edge %d --> %d.",          Node.GetId(), Node.GetId(), Node.GetNbrNId(e));        if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); }        RetVal=false;      }      prevNId = Node.GetNbrNId(e);    }  }  int EdgeCnt = 0;  for (TEdgeI EI = BegEI(); EI < EndEI(); EI++) { EdgeCnt++; }  if (EdgeCnt != GetEdges()) {    const TStr Msg = TStr::Fmt("Number of edges counter is corrupted: GetEdges():%d, EdgeCount:%d.", GetEdges(), EdgeCnt);    if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); }    RetVal=false;  }  return RetVal;}

int RestorePreferences(void){    int version;    FILE *in;    struct xmlNode *root;    struct xmlNode *nodes,  *children;    struct xmlAttr *attribs;    char  *p;     char name[256];    if (!generalProject.profiles)        generalProject.profiles = calloc(1, sizeof(PROFILE));    GetUserDataPath(name);    strcat(name, PREFFILE);    in = fopen(name, "r");    if (!in)    {        LoadDefaultRules();        return 0;    }    root = xmlReadFile(in);    fclose(in);    if (!root || !IsNode(root, "UIPREFS"))    {        LoadDefaultRules();        return 0;    }    nodes = root->children;    while (nodes)    {        if (IsNode(nodes, "VERSION"))        {            struct xmlAttr *attribs = nodes->attribs;            while (attribs)            {                if (IsAttrib(attribs, "ID"))                    version = atoi(attribs->value);                attribs = attribs->next;            }         }        else if (IsNode(nodes, "PROPERTIES"))            RestoreGeneralProps(nodes, version);        else if (IsNode(nodes, "MEMWND"))            RestoreMemoryWindowSettings(nodes, version);        else if (IsNode(nodes, "FIND"))            RestoreFindflags(nodes, version);        else if (IsNode(nodes, "PLACEMENT"))            RestorePlacement(nodes, version);        else if (IsNode(nodes, "CUSTOMCOLORS"))            RestoreCustomColors(nodes, version);        else if (IsNode(nodes, "RULES"))            RestoreBuildRules(nodes, version);        nodes = nodes->next;    }    xmlFree(root);    PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);    return 1;}

// add a node from a vector pool// (use TUNGraph::IsOk to check whether the graph is consistent)int TUNGraph::AddNode(const int& NId, const TVecPool<TInt>& Pool, const int& NIdVId) {  IAssert(NId != -1);  IAssertR(! IsNode(NId), TStr::Fmt("NodeId %d already exists", NId));  MxNId = TMath::Mx(NId+1, MxNId());  TNode& Node = NodeH.AddDat(NId);  Node.Id = NId;  Node.NIdV.GenExt(Pool.GetValVPt(NIdVId), Pool.GetVLen(NIdVId));  Node.NIdV.Sort();  return NId;}

// Add a node of ID NId to the graph.int TUNGraph::AddNode(int NId) {  if (NId == -1) {    NId = MxNId;  MxNId++;  } else {    IAssertR(!IsNode(NId), TStr::Fmt("NodeId %d already exists", NId));    MxNId = TMath::Mx(NId+1, MxNId());  }  NodeH.AddDat(NId, TNode(NId));  return NId;}

static void RestorePropsNested(struct xmlNode *input, PROJECTITEM *root, PROJECTITEM *parent){    while (input)    {        if (IsNode(input, "PROPERTIES"))        {            RestoreProps(input->children, root, parent);        }        input = input->next;    }}

NodePtr AnnotationValue::GetValueAsNode() const{	if (!IsNode())	{		std::stringstream ss;		ss << "Attempted to access " << GetTypeString() 			<< " annotation as a node.";		throw AnnotationValueTypeException(ss.str());	}	Node & node = boost::get<Node &>(value);	return NodePtr(&node);}

// Delete node of ID NId from the graph.void TUNGraph::DelNode(const int& NId) {  { AssertR(IsNode(NId), TStr::Fmt("NodeId %d does not exist", NId));  TNode& Node = GetNode(NId);  for (int e = 0; e < Node.GetDeg(); e++) {  const int nbr = Node.GetNbrNId(e);  if (nbr == NId) { continue; }    TNode& N = GetNode(nbr);    const int n = N.NIdV.SearchBin(NId);    if (n!= -1) { N.NIdV.Del(n); }  } }  NodeH.DelKey(NId);}

morkEnv* morkFactory::GetInternalFactoryEnv(nsresult* outErr) {  morkEnv* outEnv = 0;  if (IsNode() && IsOpenNode() && IsFactory()) {    morkEnv* fenv = &mFactory_Env;    if (fenv && fenv->IsNode() && fenv->IsOpenNode() && fenv->IsEnv()) {      fenv->ClearMorkErrorsAndWarnings();  // drop any earlier errors      outEnv = fenv;    } else      *outErr = morkEnv_kBadFactoryEnvError;  } else    *outErr = morkEnv_kBadFactoryError;  return outEnv;}