public static PackageVO getPackageFromEAObject(EA.Package eaPackageObj)
{
PackageVO pacvo = new PackageVO();
pacvo.packageId = eaPackageObj.PackageID;
pacvo.guid = eaPackageObj.PackageGUID;
pacvo.name = excludeSpecialChar(eaPackageObj.Name);
pacvo.alias = excludeSpecialChar(eaPackageObj.Alias);
pacvo.stereoType = excludeSpecialChar(eaPackageObj.StereotypeEx);
pacvo.treePos = eaPackageObj.TreePos;
pacvo.isControlled = eaPackageObj.IsControlled;
List <ElementVO> retElementList = new List <ElementVO>();
foreach (EA.Element elemObj in eaPackageObj.Elements)
{
retElementList.Add(getElementFromEAObject(elemObj));
}
List <PackageVO> retPackageList = new List <PackageVO>();
foreach (EA.Package subPackObj in eaPackageObj.Packages)
{
retPackageList.Add(getPackageFromEAObject(subPackObj));
}
pacvo.elements = retElementList;
pacvo.childPackageList = retPackageList;
return(pacvo);
}
/// <summary>
/// 指定したパッケージをparentPackageIdを使って先頭（ルート）まで辿り、
/// 辿った結果としてルートから子への順でパッケージIDのリストを作成し返却する
///
/// <pre>
/// id=1, root
/// id=2, xxx
/// id=3, yyy
/// id=4, zzz
/// </pre>
/// というパッケージ構造があり、このうち id=4 の zzz が指定されると、
/// 返却値は 1,3,4 という3つのパッケージIDのパッケージが格納されたリストとなる
///
/// </summary>
/// <param name="atfpac"></param>
/// <returns></returns>
private List <PackageVO> traverseFromLeafToRoot(PackageVO atfpac)
{
List <PackageVO> outList = new List <PackageVO>();
goBackRetrievePackage(atfpac, outList);
return(outList);
}
private ReturnedData AddPkg(string pkgName, decimal pkgPrice)
{
ReturnedData data = new ReturnedData();
PackageMgm pkgMgm = new PackageMgm();
PackageVO pkg = new PackageVO();
pkg.PackageName = pkgName;
pkg.TotalPrice = pkgPrice;
pkg.CreatedDate = DateTime.Now;
pkg.CreatorID = Emp.UserName;
pkg.LastModifiedDate = DateTime.Now;
pkg.LastModifierID = Emp.UserName;
try
{
data.Data = pkgMgm.AddPackage(pkg);
data.Success = true;
data.Message = "套餐基本信息添加成功";
LogHandler.Info("用户：" + Emp.UserName + "于 " + pkg.CreatedDate.ToString() + " 添加套餐基本信息，项目名：" + pkgName);
}
catch (Exception ex)
{
data.Success = false;
data.Message = "套餐基本信息添加失败";
data.Error = ex.ToString();
LogHandler.Error("套餐基本信息添加错误：" + ex.Message.ToString());
}
return(data);
}
private List <PackageVO> readAllPackage()
{
List <PackageVO> packages = new List <PackageVO>();
// XMLテキストをロードする
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(this.allPackagesXmlFilePath);
// AllPackageノードに移動する
XmlNode allPackagesNode = xmlDoc.SelectSingleNode("AllPackage");
foreach (XmlNode pkgNode in allPackagesNode.ChildNodes)
{
if (pkgNode.Name == "package")
{
PackageVO rootPackage = readPackageAttributes(pkgNode);
readRootPackage(rootPackage, pkgNode);
packages.Add(rootPackage);
}
}
// 読み込んだルートパッケージをソート
packages.Sort();
return(packages);
}
/// <summary>
/// パッケージ単位での追加(C)・削除(D)があったら配下の要素と、さらに属性・メソッドに伝搬する
/// </summary>
/// <param name="pkg"></param>
/// <param name="updChanged"></param>
private void setChangedToChilds(PackageVO pkg, char updChanged)
{
pkg.changed = updChanged;
foreach (PackageVO p in pkg.childPackageList)
{
setChangedToChilds(p, updChanged);
}
foreach (ElementVO e in pkg.elements)
{
e.changed = updChanged;
foreach (AttributeVO a in e.attributes)
{
a.changed = updChanged;
}
foreach (MethodVO m in e.methods)
{
m.changed = updChanged;
}
}
return;
}
/// <summary>
/// パッケージの子を辿り、成果物マーク(isControlled)が立っているパッケージを成果物としてリストに追加する
/// </summary>
/// <param name="pkg"></param>
/// <param name="parentPath"></param>
private void searchArtifactPackage(PackageVO pkg, string parentPath, List <ArtifactVO> outArtifacts)
{
string nowPath = parentPath + "/" + pkg.name;
if (pkg.isControlled)
{
Console.WriteLine("hit artifactTarget: guid=" + pkg.guid + ", path=" + nowPath);
// 成果物VOを生成し、このパッケージを対象にする
ArtifactVO atf = new ArtifactVO();
atf.guid = pkg.guid;
atf.name = pkg.name;
atf.pathName = parentPath;
atf.projectName = rootName;
atf.package = pkg;
// 出力用の成果物リストに追加
outArtifacts.Add(atf);
}
else
{
if (pkg.childPackageList != null)
{
foreach (PackageVO p in pkg.childPackageList)
{
searchArtifactPackage(p, nowPath, outArtifacts);
}
}
}
}
/// <summary>
/// 下から上にパッケージを辿る。
/// 返却リストは階層の上から順にパッケージが並ぶように、先頭に追加する
/// </summary>
/// <param name="pac"></param>
/// <param name="outList"></param>
private void goBackRetrievePackage(PackageVO pac, List <PackageVO> outList)
{
// 返却値となるパッケージのリスト
outList.Insert(0, pac);
// 親パッケージIDが０になったら終了
if (pac.parentPackageId > 0)
{
// 親パッケージIDから親が辿れたら、親パッケージを引数にして自メソッドを再帰呼び出しする
if (this.targetPackageMap.ContainsKey(pac.parentPackageId))
{
PackageVO ppac = this.targetPackageMap[pac.parentPackageId];
goBackRetrievePackage(ppac, outList);
}
else
{
// throw new Exception("親PackageId が不正です : " + pac.parentPackageId);
Console.WriteLine("親PackageId が不正です : " + pac.parentPackageId);
}
}
else
{
return;
}
}
/// <summary>
/// 引数のPackageリストを、ルートから目的のパッケージまでの経路と見立て、
/// 先頭から階層順に出力パッケージツリー内の存在チェックを行い、存在しない階層が来たらそれ以降を出力パッケージツリーに加える
/// </summary>
/// <param name="packages"></param>
/// <param name="idx"></param>
/// <param name="parentPackage"></param>
/// <param name="targetPackages"></param>
private void searchAndConcatChildNodes(List <PackageVO> packages, int idx, PackageVO artifactPackage, PackageVO parentPackage, List <PackageVO> targetPackages)
{
if (idx >= packages.Count)
{
return;
}
PackageVO myPackage = packages[idx];
int myPackageId = myPackage.packageId;
bool foundFlg = false;
foreach (PackageVO ppac in targetPackages)
{
// parentPackagesの中に自分のIDが存在している場合、
// 対象の階層で一致している間は階層を下げて自メソッドを再帰呼び出しする
if (ppac.packageId == myPackageId)
{
searchAndConcatChildNodes(packages, idx + 1, artifactPackage, ppac, ppac.childPackageList);
foundFlg = true;
break;
}
}
// 同レベルに見つからなかったということは、これ以降のパッケージは全て追加でよいので
// 以降は単純な追加処理を呼ぶ
if (!foundFlg)
{
concatChildNodes(packages, idx, artifactPackage, parentPackage);
}
}
/// <summary>
/// 引数のパッケージリストを１階層ずつ指定の親パッケージの子として追加する
/// </summary>
/// <param name="packages"></param>
/// <param name="idx"></param>
/// <param name="parentPackage"></param>
private void concatChildNodes(List <PackageVO> packages, int idx, PackageVO artifactPackage, PackageVO parentPackage)
{
if (idx >= packages.Count)
{
return;
}
PackageVO myPackage;
// リスト内の最後の１件は成果物パッケージ(isControlledがtrue)なので、引数の成果物パッケージの方を追加する
if (idx == packages.Count - 1)
{
myPackage = artifactPackage;
}
else
{
myPackage = packages[idx];
}
parentPackage.childPackageList.Add(myPackage);
if (!outPackageMap.ContainsKey(myPackage.packageId))
{
outPackageMap.Add(myPackage.packageId, myPackage);
}
else
{
Console.WriteLine("PackageIdがOutPackageMap内で重複しました : " + myPackage.packageId);
}
concatChildNodes(packages, idx + 1, artifactPackage, myPackage);
}
/// <summary>
/// ドキュメント出力対象の要素を数える
/// </summary>
/// <param name="package">対象パッケージ</param>
/// <returns>パッケージ直下の要素数</returns>
private static int countPrintableElement(PackageVO package)
{
int elemCount = 0;
if (package.elements != null && package.elements.Count > 0)
{
foreach (ElementVO elem in package.elements)
{
if (elem.eaType == "Class" || elem.eaType == "Interface" || elem.eaType == "Enumeration" || elem.eaType == "UseCase" || elem.eaType == "Actor")
{
elemCount++;
}
}
return(elemCount);
}
else
{
if (package.diagrams != null && package.diagrams.Count > 0)
{
return(package.diagrams.Count);
}
return(0);
}
}
/// <summary>
/// ルート（parentIdが0）パッケージ情報を取得する
/// </summary>
/// <returns>ルートパッケージのリスト</returns>
private List <PackageVO> readAllRootPackages()
{
Console.WriteLine("readAllRootPackages()");
string strSQL;
strSQL =
"SELECT pac.PACKAGE_ID " +
" ,pac.ea_guid " +
" ,pac.NAME " +
" ,obj.Alias " +
" ,obj.Stereotype " +
" ,pac.PARENT_ID " +
" ,pac.TPOS " +
" ,pac.IsControlled " +
" FROM t_package pac left outer join t_object obj on pac.ea_guid = obj.ea_guid " +
" WHERE pac.PARENT_ID = 0 ";
OleDbCommand dbCom = new OleDbCommand();
// SQLを実行する
dbCom.CommandText = strSQL;
dbCom.Connection = objConn;
using (OleDbDataReader reader = dbCom.ExecuteReader())
{
// 結果を表示します。
while (reader.Read())
{
PackageVO rootPack = new PackageVO();
rootPack.packageId = DbUtil.readIntField(reader, 0);
rootPack.guid = DbUtil.readStringField(reader, 1);
rootPack.name = StringUtil.excludeSpecialChar("t_package", "name", rootPack.guid, DbUtil.readStringField(reader, 2));
rootPack.alias = StringUtil.excludeSpecialChar("t_object", "alias", rootPack.guid, DbUtil.readStringField(reader, 3));
rootPack.stereoType = DbUtil.readStringField(reader, 4);
rootPack.parentPackageId = DbUtil.readIntField(reader, 5);
rootPack.treePos = DbUtil.readIntField(reader, 6);
rootPack.isControlled = DbUtil.readBoolField(reader, 7);
rootPack.pathName = "/" + rootPack.name;
// このパッケージ配下の要素を読み込み
// readElements(rootPack);
// パッケージ配下のパッケージを読み込み（再帰処理）
readSubPackage(rootPack, false);
// 返却用のパッケージリストにこのパッケージを追加
rootPackages.Add(rootPack);
// 全パッケージマップのキャッシュに、Key=IDとして追加
AllPackageMap.Add(rootPack.packageId, rootPack);
}
}
return(rootPackages);
}
public Model.VO.PackageVO GetPackageByID(int id)
{
PackageData packageData = new PackageData();
PackageVO packageVO = new PackageVO();
PackagePO packagePO = packageData.GetPackageByID(id);
packageVO = Mapper.Map <PackagePO, PackageVO>(packagePO);
return(packageVO);
}
/// <summary>
///
/// </summary>
/// <param name="package"></param>
/// <param name="sw"></param>
/// <param name="packagePath"></param>
private void writePackage(PackageVO package, StreamWriter sw, string packagePath)
{
string pathName = "";
if (packagePath != "")
{
pathName = packagePath + "/" + package.name;
}
else
{
pathName = package.name;
}
// 要素別AsciiDocファイルの出力先を指定
string elementsDir = ProjectSetting.getVO().projectPath + "\\elements";
// 直下に出力すべき要素が１つも存在しないパッケージは出力の対象外とする（ドキュメント内での項番も不要）
if (countPrintableElement(package) > 0)
{
sw.WriteLine("## パッケージ: " + pathName);
sw.WriteLine("// GUID: " + package.guid);
sw.WriteLine("");
// このパッケージ直下にダイアグラムを持っていたら
if (package.diagrams != null && package.diagrams.Count > 0)
{
foreach (DiagramVO diag in package.diagrams)
{
// writeDiagramData(diag, sw);
writeDiagramPlantUml(diag, sw);
}
}
foreach (ElementVO elem in package.elements)
{
if (elem.eaType == "Class" || elem.eaType == "Interface" || elem.eaType == "Enumeration" || elem.eaType == "UseCase" || elem.eaType == "Actor")
{
//ElementAsciidocWriter.writeElement(elem, sw);
string relPath = ElementAsciidocWriter.doWrite(elementsDir, elem);
writeElementInclude(sw, relPath);
}
}
sw.WriteLine("<<<");
sw.WriteLine("");
}
if (package.childPackageList != null && package.childPackageList.Count > 0)
{
foreach (PackageVO pkg in package.childPackageList)
{
writePackage(pkg, sw, pathName);
}
}
}
public PackageVO GetPackageByID(int id)
{
PackageVO package = new PackageVO()
{
PackageID = 1,
PackageName = "车身美容套餐",
TotalPrice = 345
};
return(package);
}
private PackageVO searchFromAllPackageMap(int packageId)
{
PackageVO pack = new PackageVO();
if (AllPackageMap.ContainsKey(packageId))
{
pack = AllPackageMap[packageId];
}
return(pack);
}
/// <summary>
/// 要素CSVファイルの明細行出力
/// </summary>
/// <param name="pack"></param>
/// <param name="elem"></param>
/// <param name="csvsw"></param>
private void writeElementCsv(PackageVO pack, ElementVO elem, StreamWriter csvsw)
{
csvsw.Write(addQuote(pack.guid));
csvsw.Write("," + addQuote(pack.stereoType));
csvsw.Write("," + addQuote(pack.pathName));
csvsw.Write("," + addQuote(elem.guid));
csvsw.Write("," + addQuote(elem.eaType));
csvsw.Write("," + addQuote(elem.name));
csvsw.Write("," + addQuote(elem.stereoType));
csvsw.Write("," + addQuote(elem.tag));
csvsw.Write("\r\n");
}
/// <summary>
/// 詳細のXMLファイルを出力する（パッケージ）
/// </summary>
/// <param name="atf">成果物VO</param>
/// <param name="pkg">パッケージ</param>
/// <param name="sw">出力ストリームライター</param>
private void outputDetailXmlPackage(PackageVO pkg)
{
foreach (ElementVO e in pkg.elements)
{
outputDetailXmlElement(e);
}
foreach (PackageVO p in pkg.childPackageList)
{
outputDetailXmlPackage(p);
}
}
private void outputChangedSummaryPackage(ArtifactVO atf, PackageVO pkg, StreamWriter sw)
{
foreach (ElementVO e in pkg.elements)
{
outputChangedSummaryElement(atf, e, sw);
}
foreach (PackageVO p in pkg.childPackageList)
{
outputChangedSummaryPackage(atf, p, sw);
}
}
private PackageVO readPackageAttributes(XmlNode pkgNode)
{
PackageVO pkg = new PackageVO();
foreach (XmlAttribute attr in pkgNode.Attributes)
{
switch (attr.Name)
{
case "PackageID":
pkg.packageId = readAttributeIntValue(attr);
break;
case "name":
pkg.name = attr.Value;
break;
case "guid":
pkg.guid = attr.Value;
break;
case "Alias":
pkg.alias = attr.Value;
break;
case "stereotype":
pkg.stereoType = attr.Value;
break;
case "TPos":
pkg.treePos = readAttributeIntValue(attr);
break;
case "parentPackageId":
pkg.parentPackageId = readAttributeIntValue(attr);
break;
case "changed":
pkg.changed = readAttributeCharValue(attr);
break;
case "elementsCount":
pkg.elementsCount = readAttributeIntValue(attr);
break;
case "diagramsCount":
pkg.diagramsCount = readAttributeIntValue(attr);
break;
}
}
return(pkg);
}
public List <PackageVO> GetAllPackages()
{
List <PackageVO> result = new List <PackageVO>();
#region Mock
PackageVO item1 = new PackageVO()
{
PackageID = 1,
PackageName = "车身美容套餐",
TotalPrice = 345
};
PackageVO item2 = new PackageVO()
{
PackageID = 2,
PackageName = "内部美容套餐",
TotalPrice = 321
};
PackageVO item3 = new PackageVO()
{
PackageID = 3,
PackageName = "漆面处理套餐",
TotalPrice = 453
};
PackageVO item4 = new PackageVO()
{
PackageID = 4,
PackageName = "汽车防护套餐",
TotalPrice = 231
};
PackageVO item5 = new PackageVO()
{
PackageID = 5,
PackageName = "杀菌消毒套餐",
TotalPrice = 231
};
result.Add(item1);
result.Add(item2);
result.Add(item3);
result.Add(item4);
result.Add(item5);
#endregion
return(result);
}
/// <summary>
/// パッケージの読み込み（再帰処理）
/// 引数のパッケージノード以下を再帰的に読み込み、 Package, Element をVOに読み込む
/// </summary>
/// <param name="pkgvo">(out)パッケージのVO</param>
/// <param name="parentNode">(in)対象のパッケージのXmlNode</param>
private void readPackages(PackageVO pkgvo, XmlNode parentNode)
{
List <PackageVO> retList = new List <PackageVO>();
List <ElementVO> retElementList = new List <ElementVO>();
List <DiagramVO> retDiagramList = new List <DiagramVO>();
PackageVO pkg = null;
foreach (XmlNode pkgNode in parentNode.ChildNodes)
{
if ("package".Equals(pkgNode.Name))
{
pkg = readPackageNode(pkgNode);
readPackages(pkg, pkgNode);
retList.Add(pkg);
}
// package配下で elementノードを見つけたら
if ("element".Equals(pkgNode.Name))
{
// elementノード配下の情報から、 ElementVO を返却する
ElementVO elem = ElementsXmlReader.readElement(pkgNode, sortByPosFlg);
elem.packageId = pkgvo.packageId;
// 強いてelement毎のXMLファイルを読む必要がある場合のみ
if (elementFileReadFlg)
{
// 強いてelement毎のXMLファイルを読む必要がある場合のみ
if (ElementsXmlReader.existElementFile(elem.guid))
{
elem = ElementsXmlReader.readElementFile(elem.guid);
}
}
retElementList.Add(elem);
}
// package配下で diagram ノードを見つけたら
if ("diagram".Equals(pkgNode.Name))
{
retDiagramList.Add(readDiagramNode(pkgNode));
}
}
pkgvo.childPackageList = retList;
pkgvo.elements = retElementList;
pkgvo.diagrams = retDiagramList;
}
private void setChangedToChilds(PackageVO pkg, char updChanged)
{
pkg.changed = updChanged;
foreach (PackageVO p in pkg.childPackageList)
{
setChangedToChilds(p, updChanged);
}
foreach (ElementVO e in pkg.elements)
{
e.changed = updChanged;
}
return;
}
private PackageVO readPackageNode(XmlNode pkgNode)
{
PackageVO pkg = new PackageVO();
foreach (XmlAttribute attr in pkgNode.Attributes)
{
switch (attr.Name)
{
case "PackageID":
pkg.packageId = readAttributeIntValue(attr);
break;
case "parentPackageId":
pkg.parentPackageId = readAttributeIntValue(attr);
break;
case "name":
pkg.name = attr.Value;
break;
case "isControlled":
pkg.isControlled = readAttributeBooleanValue(attr);
break;
case "guid":
pkg.guid = attr.Value;
break;
case "alias":
pkg.alias = attr.Value;
break;
case "stereoType":
pkg.stereoType = attr.Value;
break;
case "TPos":
pkg.treePos = readAttributeIntValue(attr);
break;
case "changed":
pkg.changed = readAttributeCharValue(attr);
break;
}
}
return(pkg);
}
private TreeNode makePackageNode(TreeNode parentNode, PackageVO pac, Boolean isRoot)
{
TreeNode targetNode = new TreeNode(pac.name, 0, 1);
if (isRoot == false)
{
parentNode.Nodes.Add(targetNode);
}
foreach (PackageVO c in pac.childPackageList)
{
makePackageNode(targetNode, c, false);
}
return(targetNode);
}
/// <summary>
/// 成果物パッケージの読み込み
/// </summary>
/// <param name="parentNode">packageを子として持つ親のartifactノード</param>
/// <returns>読み込まれた成果物のパッケージVO（常に１つ）</returns>
private void readRootPackage(PackageVO rootPackage, XmlNode parentNode)
{
// 成果物のルートパッケージから再帰的に子パッケージを読み込み
readPackages(rootPackage, parentNode);
// ソート順指定フラグにより、ソート処理が分かれる
if (this.sortByPosFlg)
{
rootPackage.sortChildNodes();
}
else
{
rootPackage.sortChildNodesGuid();
}
return;
}
/// <summary>
/// 全属性・操作CSVに操作行を追加
/// </summary>
/// <param name="pak">パッケージVO</param>
/// <param name="elem">要素VO</param>
/// <param name="mth">操作VO</param>
/// <param name="csvsw">出力ストリーム</param>
private void writeCsvFileMethod(PackageVO pak, ElementVO elem, MethodVO mth, StreamWriter csvsw)
{
csvsw.Write("" + addQuote(pak.guid));
csvsw.Write("," + addQuote(pak.stereoType));
csvsw.Write("," + addQuote(pak.pathName));
csvsw.Write("," + addQuote(elem.guid));
csvsw.Write("," + addQuote(elem.eaType));
csvsw.Write("," + addQuote(elem.name));
csvsw.Write("," + addQuote(elem.stereoType));
// csvsw.Write("," + elem.tag);
csvsw.Write("," + addQuote("m"));
csvsw.Write("," + addQuote(mth.guid));
csvsw.Write("," + addQuote(mth.name));
csvsw.Write("," + addQuote(mth.alias));
csvsw.Write("," + addQuote(mth.getParamDesc()));
csvsw.Write("\r\n");
}
/// <summary>
/// 全属性・操作CSVに属性行を追加
/// </summary>
/// <param name="atf">成果物VO</param>
/// <param name="elem">要素VO</param>
/// <param name="attr">属性VO</param>
/// <param name="csvsw">出力ストリーム</param>
private void writeCsvFileAttr(PackageVO pak, ElementVO elem, AttributeVO attr, StreamWriter csvsw)
{
csvsw.Write("" + addQuote(pak.guid));
csvsw.Write("," + addQuote(pak.stereoType));
csvsw.Write("," + addQuote(pak.pathName));
csvsw.Write("," + addQuote(elem.guid));
csvsw.Write("," + addQuote(elem.eaType));
csvsw.Write("," + addQuote(elem.name));
csvsw.Write("," + addQuote(elem.stereoType));
// csvsw.Write("," + elem.tag);
csvsw.Write("," + addQuote("a"));
csvsw.Write("," + addQuote(attr.guid));
csvsw.Write("," + addQuote(attr.name));
csvsw.Write("," + addQuote(attr.alias));
csvsw.Write("," + addQuote(""));
csvsw.Write("\r\n");
}
private void rewriteElementXmlPackage(PackageVO pkg)
{
if (pkg.childPackageList.Count > 0)
{
foreach (PackageVO p in pkg.childPackageList)
{
rewriteElementXmlPackage(p);
}
}
if (pkg.elements.Count > 0)
{
foreach (ElementVO elem in pkg.elements)
{
ElementXmlWriter.outputElementXmlFile(elem);
}
}
}
/// <summary>
/// 引数のパッケージを再帰的に読み込み、配下のelementsをさらにretrieveする
/// </summary>
/// <param name="package"></param>
/// <param name="csvsw"></param>
/// <param name="outputType"></param>
private void retrievePackage(PackageVO package, StreamWriter csvsw, short outputType)
{
if (package.elements != null)
{
foreach (var elem in package.elements)
{
retrieveElement(package, elem, csvsw, outputType);
}
}
if (package.childPackageList != null)
{
foreach (var pak in package.childPackageList)
{
retrievePackage(pak, csvsw, outputType);
}
}
}
private ChildrenCounters getChildrenNodeCount(PackageVO packageNode)
{
// 自分と子の分のカウント数を入れる入れ物を用意
ChildrenCounters counters = new ChildrenCounters();
// まず自分が保持する要素の数とダイアグラムの数をセット
if (packageNode.elements != null)
{
counters.elementsCount = packageNode.elements.Count;
}
else
{
packageNode.elementsCount = 0;
}
if (packageNode.diagrams != null)
{
counters.diagramsCount = packageNode.diagrams.Count;
}
else
{
packageNode.diagramsCount = 0;
}
// 子パッケージがある場合、子の分の数も自分に集計する
if (packageNode.childPackageList != null && packageNode.childPackageList.Count > 0)
{
// 子の分の要素数とダイアグラム数を取得し、それぞれ自分のカウンタに足しこむ
for (int i = 0; i < packageNode.childPackageList.Count; i++)
{
ChildrenCounters childCount = getChildrenNodeCount(packageNode.childPackageList[i]);
counters.elementsCount += childCount.elementsCount;
counters.diagramsCount += childCount.diagramsCount;
}
}
// 最後に、要素数とダイアグラム数を自ノードにセット
packageNode.elementsCount = counters.elementsCount;
packageNode.diagramsCount = counters.diagramsCount;
return(counters);
}
