类图到源码分析工具----合并元素处理，图的同构，回环处理

练手最多的也就是广搜，今天连个状态机也写不出来，弱，非常的弱，眼高手低的毛病一直没改，幸好我周围好人很多，很多。

 

分析一下处理这个图的同构和回环处理方法。

首先是第一种情况，两个类图，要合并的元素是一样的类或者接口。可以这样理解为一个为正本，一个为副本。方法如下：

1，把副本的目标元素，删除，正本顶替副本的位置。

2，只要副本直接关联元素和间接关联元素显示为TRUE，则直接把正本的直接和间接关联元素替换为副本的元素。不管正本那边的关联元素为true

或者为false;

3，如果副本关联元素为false,则服从于正本关联元素。

本着这个想法，先对副本做一次广搜，然后把显示为true的元素入队列，接着和正本元素映射，但凡映射上的元素执行两个步骤，替换自己的位置，替换和目标元素直接关联元素内存储的目标元素。例如目标元素A的关联元素是B,C，D，那么B,C,D里面有A，如果A替换为a,那么B,C,D里面也要替换A为a。

 

于是乎就有了以下代码：

/** * 合并各元素 * @param ve * @return * 此处的思想是把副本全部元素删除，并且把副本visible为true的元素信息赋给原本 */ override public function mergeWith(ve:ICIViewElement) : int { if (ve == null) return EG.Result_S_FALSE; var mergeObject: Array = _getMergeObject(ve); if (mergeObject == null) return EG.Result_S_OK; var beenVisited: Array = new Array(); var length: int = mergeObject["length"]; var visited: int = 0; var begin: int = 0; var thisQueue: Vector.<ICIViewElement> = new Vector.<ICIViewElement>(); thisQueue.push(this); beenVisited[this.fullName] = false; while (visited != length && begin != thisQueue.length) { var currThis: ICIViewElement = thisQueue[begin]; beenVisited[currThis.fullName] = true; //从映射数组中取出信息和当前同构图中的节点信息匹配，并且把副本节点删除 var currVe: ICIViewElement = mergeObject[currThis.fullName]; if (currVe) { currVe.deleteThis(); visited++; currThis.myVisible = true; currThis.myX = currVe.myX; currThis.myY = currVe.myY; currThis.refresh(); CT.refreshAllRelationLines(currThis); _view.elementPool.posChanged(currThis); } //关联元素处理各自容器中的目标元素值 //当当前节点是class元素时候，根据条件加入队列中 if (currThis.eType == EG.Element_CLASS) { var thisParClass: ICIClass = ICIClass(currThis).parent if (thisParClass && mergeObject[thisParClass.fullName]) { if (!beenVisited[thisParClass.fullName]) thisQueue.push(thisParClass); } var thisChildsClass: Vector.<ICIClass> = ICIClass(currThis).childs; for each (var chlClass: ICIClass in thisChildsClass) { if (beenVisited[chlClass.fullName]) continue; if (mergeObject[chlClass.fullName]) thisQueue.push(chlClass); } var thisInterfaceClass: Vector.<ICIInterface> = ICIClass(currThis).interfaces; for each (var interClass: ICIInterface in thisInterfaceClass) { if (beenVisited[interClass.fullName]) continue; if (mergeObject[interClass.fullName]) thisQueue.push(interClass); } var thisUsersClass: Vector.<ICIClass> = ICIClass(currThis).users; for each (var userClass: ICIClass in thisUsersClass) { if (beenVisited[userClass.fullName]) continue; if (mergeObject[userClass.fullName]) thisQueue.push(userClass); } var thisData: IClass = currThis.data as IClass; for each (var mem: IClassMember in thisData.members) { if (beenVisited[mem.type.fullName]) continue; if (mergeObject[mem.type.fullName]) { var ve: ICIViewElement = ICIView(_view).createElementByData(mem.type) as ICIViewElement; thisQueue.push(ve); } } } else if (currThis.eType == EG.Element_INTERFACE) {//当元素为接口元素时候的处理 var thisPar: Vector.<ICIInterface> = ICIInterface(currThis).parents; for each (var par: ICIInterface in thisPar) { if (beenVisited[par.fullName]) continue; if (mergeObject[par.fullName]) thisQueue.push(par); } var thisChilds: Vector.<ICIInterface> = ICIInterface(currThis).childs; for each (var chl: ICIInterface in thisChilds) { if (beenVisited[chl.fullName]) continue; if (mergeObject[chl.fullName]) thisQueue.push(chl); } var thisUsers: Vector.<ICIClass> = currThis.users; for each (var user: ICIClass in thisUsers) { if (beenVisited[user.fullName]) continue; if (mergeObject[user.fullName]) thisQueue.push(user); } var thisImpls: Vector.<ICIClass> = ICIInterface(currThis).implementors; for each (var impl: ICIClass in thisImpls) { if (beenVisited[impl.fullName]) continue; if (mergeObject[impl.fullName]) thisQueue.push(impl); } } begin++; } // this.refresh(); return EG.Result_S_OK; } /** * 广搜获取副本已经显示的元素 * @param ve * @return */ private function _getMergeObject(ve: ICIViewElement): Array { var mergeObject: Array = new Array(); var mergeVisited: Array = new Array(); var mergeVec: Vector.<ICIViewElement> = new Vector.<ICIViewElement>(); var begin: int = 0; mergeVec.push(ve); mergeObject[ve.fullName] = ve; mergeVisited[ve.id] = false; while (begin != mergeVec.length) { var currVe: ICIViewElement = mergeVec[begin]; mergeVisited[currVe.id] = true; //此处分为class元素和interface元素处理情况 if (currVe.eType == EG.Element_CLASS) { var veParClass: ICIClass = ICIClass(currVe).createdParent; if (veParClass && veParClass.myVisible && !mergeVisited[veParClass.id]) { mergeVec.push(veParClass); mergeObject[veParClass.fullName] = veParClass; } var veChildsClass: Vector.<ICIClass> = ICIClass(currVe).createdChilds; for each (var chlClass: ICIClass in veChildsClass) { if (chlClass.myVisible && !mergeVisited[chlClass.id]) { mergeVec.push(chlClass); mergeObject[chlClass.fullName] = chlClass; } } var veInterfaceClass: Vector.<ICIInterface> = ICIClass(currVe).createdInterfaces; for each (var interClass: ICIInterface in veInterfaceClass) { if (interClass == this) { _replaceElment(ve, currVe); return null; } if (!mergeVisited[interClass.id] && interClass.myVisible) { mergeVec.push(interClass); mergeObject[interClass.fullName] = interClass; } } var veUsersClass: Vector.<ICIClass> = ICIClass(currVe).createdUsers; for each (var userClass: ICIClass in veUsersClass) { if (!mergeVisited[userClass.id] && userClass.myVisible) { mergeVec.push(userClass); mergeObject[userClass.fullName] = userClass; } } var veTypeClass: Vector.<ICIViewElement> = ICIClass(currVe).createdMemberTypes; for each (var typeClass: ICIViewElement in veTypeClass) { if (typeClass == this) { _replaceElment(ve, currVe); return null; } if (!mergeVisited[typeClass.id] && typeClass.myVisible) { mergeVec.push(typeClass); mergeObject[typeClass.fullName] = typeClass; } } } else if (currVe.eType == EG.Element_INTERFACE) { var vePar: Vector.<ICIInterface> = ICIInterface(currVe).createdParents; for each (var par: ICIInterface in vePar) { if (par == this) { _replaceElment(ve, currVe); return null; } if (par.myVisible && !mergeVisited[par.id]) { mergeVec.push(par); mergeObject[par.fullName] = par; } } var veChilds: Vector.<ICIInterface> = ICIInterface(currVe).createdChilds; for each (var chl: ICIInterface in veChilds) { if (chl == this) { _replaceElment(ve, currVe); return null; } if (chl.myVisible && !mergeVisited[chl.id]) { mergeVec.push(chl); mergeObject[chl.fullName] = chl; } } var veUsers: Vector.<ICIClass> = currVe.createdUsers for each (var user: ICIClass in veUsers) { if (!mergeVisited[user.id] && user.myVisible) { mergeVec.push(user); mergeObject[user.fullName] = user; } } var veImpls: Vector.<ICIClass> = ICIInterface(currVe).createdImplementors; for each (var impl: ICIClass in veImpls) { if (!mergeVisited[impl.id] && impl.myVisible) { mergeVec.push(impl); mergeObject[impl.fullName] = impl; } } } begin++; } mergeObject["length"] = mergeVec.length; return mergeObject; }  

CSDN居然没能控制长宽。

 

处理另一种情况：处理圆环情况。

和前辈讨论了一下，明白了情况，问题解决方法就浮出水面。

有一条回路，A,B,C,D,A。现在要合并两个A，另外有两个A各自带了E,F和E,F。元素都相同的。合并的时候要区分回路上的元素和非回路上的元素，一开始，讨论出，要从副本每个元素都跑一遍，也就是每个元素都深搜一遍看看是不是在一条回路上，后来想了想，从正本那边出发就不用了去考虑那么多了，因为从副本到正本只有一条路，只要获得了正本就说明和正本直接关联的那个元素N就在回路上，那么就不处理N，直接处理把副本删除，和正本的非N得直接关联元素删除，把正本元素和副本的直接关联元素黏合。黏合方法和上述一样。

 

加多这个处理函数

/** * deal with ring situation while in mergeBfs * @return */ private function _replaceElment(ve: ICIViewElement, closeElem: ICIViewElement): int { ve.deleteThis(); var index: int = 0; var pars: Vector.<ICIInterface> = ICIInterface(ve).parents; var thisPars: Vector.<ICIInterface> = ICIInterface(this).parents; for each (var par: ICIInterface in pars) { for each (var thisPar: ICIInterface in thisPars) { if (thisPar.fullName == par.fullName && thisPar.fullName != closeElem.fullName) { if (par.myVisible) { thisPar.deleteThis(); par.addChild(this); this.addParent(par); } break; } index++; } index = 0; par.refreshRelationLines(); } var childs: Vector.<ICIInterface> = ICIInterface(ve).childs; var thisChilds: Vector.<ICIInterface> = ICIInterface(this).childs; for each (var chl: ICIInterface in childs) { for each (var thisChl: ICIInterface in thisChilds) { if (thisChl.fullName == chl.fullName && thisChl.fullName != closeElem.fullName) { if (chl.myVisible) { thisChl.deleteThis(); chl.addParent(this); this.addChild(chl); } break; } index++; } index = 0; chl.refreshRelationLines(); } var impls: Vector.<ICIClass> = ICIInterface(ve).implementors; var thisImpls: Vector.<ICIClass> = ICIInterface(this).implementors; for each (var impl: ICIClass in impls) { for each (var thisImpl: ICIClass in thisImpls) { if (thisImpl.fullName == impl.fullName && thisImpl.fullName != closeElem.fullName) { if (impl.myVisible) { thisImpl.deleteThis(); impl.addInterface(this); this.addImplementor(impl); } break; } index++; } index = 0; impl.refreshRelationLines(); } var users: Vector.<ICIClass> = ICIInterface(ve).users; var thisUsers: Vector.<ICIClass> = ICIInterface(this).users; for each (var user: ICIClass in users) { for each (var thisUser: ICIClass in thisUsers) { if (thisUser.fullName == user.fullName && thisUser.fullName != closeElem.fullName) { if (user.myVisible) { thisUser.deleteThis(); user.addMemberType(this); this.addUser(user); } break; } } index = 0; user.refreshRelationLines(); } this.refreshRelationLines(); return EG.Result_S_OK; } 

 

有个关键问题，一开始是以元素名字映射防止返回已经遍历过的元素，但是在回路上，是有出现双胞胎的情况，遍历过的这个元素名很可能在回路上也存在。所以改为用id单独映射。

 

图这块当初没好好学。现在我的心态确实很浮躁。好好地干自己的分内事。