private IEnumerable <CyPhy.ComponentAssembly> GetAllComponentAssemblys(IMgaProject project, bool includeLibraries = false)
{
var filter = project.CreateFilter();
filter.Kind = "ComponentAssembly";
int componentsId = project.RootMeta.RootFolder.GetDefinedFolderByNameDisp("Components", true).MetaRef;
int componentAssembliesId = project.RootMeta.RootFolder.GetDefinedFolderByNameDisp("ComponentAssemblies", true).MetaRef;
IEnumerable <MgaFolder> rootFolders = new MgaFolder[] { project.RootFolder };
if (includeLibraries)
{
rootFolders = rootFolders.Concat(
project.RootFolder.ChildFolders.Cast <MgaFolder>().Where(f => String.IsNullOrEmpty(f.LibraryName) == false));
}
foreach (MgaFolder rootFolder in rootFolders)
{
foreach (MgaFolder folder in rootFolder.ChildFolders)
{
int metaRef = folder.MetaBase.MetaRef;
if (metaRef == componentsId || metaRef == componentAssembliesId)
{
foreach (IMgaObject fco in folder.GetDescendantFCOs(filter))
{
yield return(CyPhyClasses.ComponentAssembly.Cast(fco));
}
}
}
}
}
private static string GetNamespaceName(MgaObject obj)
{
Contract.Requires(obj != null);
string ns = "";
MgaModel paradigmSheet = null;
MgaFolder rootFolder = null;
if (obj.MetaBase.Name == "RootFolder")
{
rootFolder = obj as MgaFolder;
}
else
{
paradigmSheet = (obj as MgaFCO).ParentModel;
rootFolder = GetLibraryRoot(paradigmSheet.ParentFolder);
}
try
{
ns = rootFolder.RegistryValue["Namespace"];
}
catch
{
// com exception...
}
return(ns);
}
private void RemoveEmptyDuplicatedFolders(MgaFolder mgaFolder)
{
foreach (MgaFolder childFolder in mgaFolder.ChildFolders)
{
if (childFolder.IsLibOrLibObject() == false)
{
this.RemoveEmptyDuplicatedFolders(childFolder);
}
}
var uniqueNames = mgaFolder
.ChildFolders
.Cast <MgaFolder>()
.Where(x => x.IsLibOrLibObject() == false)
.Select(x => x.Name)
.Distinct()
.ToList();
foreach (var uniqueFolderName in uniqueNames)
{
var firstObj = mgaFolder.ChildFolders.Cast <MgaFolder>().Where(x => x.IsLibOrLibObject() == false).Where(x => x.Name == uniqueFolderName).FirstOrDefault();
var foldersToDelete = mgaFolder.ChildFolders.Cast <MgaFolder>().Where(x => x.IsLibOrLibObject() == false).Where(x => x != firstObj).Where(x => x.Name == uniqueFolderName).Where(x => x.ChildObjects.Count == 0).ToList();
foldersToDelete.ForEach(x => x.DestroyObject());
}
}
private static void GenerateAssemblies(MgaFolder componentAssemblyFolder, MgaModel assembly, int level, MgaModel leaf)
{
var elementsOnEachLevel = 2;
var numberOfLevels = 6;
if (level <= numberOfLevels)
{
System.Console.Out.WriteLine(level);
MgaFolder componentAssemblyChildFolder = componentAssemblyFolder.CreateFolder(componentAssemblyFolder.Project.RootMeta.RootFolder.DefinedFolderByName["ComponentAssemblies", true]);
componentAssemblyChildFolder.Name = string.Format("ComponentAssembly Child folder {0}", level);
for (int i = 0; i < elementsOnEachLevel; i++)
{
var childAssembly = componentAssemblyChildFolder.CreateRootObject(assembly.Meta) as MgaModel;
childAssembly.Name = string.Format("ChildAssembly {0} {1}", level, i);
var cref = assembly.CreateChildObject((assembly.Meta as GME.MGA.Meta.MgaMetaModel).RoleByName["ComponentRef"]) as MgaReference;
cref.Name = string.Format("ComponentRef {0} {1}", level, i);
if (level < numberOfLevels)
{
cref.Referred = childAssembly as MgaFCO;
GenerateAssemblies(componentAssemblyFolder, childAssembly, level + 1, leaf);
}
else
{
cref.Referred = leaf as MgaFCO;
}
}
}
}
private bool willBeMigrated(MgaFolder folder)
{
if (folder == RootFolder)
{
return(true);
}
return(folder.ParentFolder != null && willBeMigrated(folder.ParentFolder));
}
public void migrateModel(MgaModel rootmodel)
{
RootFolder = null;
RootModel = rootmodel;
createNewFCOs(rootmodel);
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
private List <MgaFolder> getAllFolders(MgaFolder folder)
{
List <MgaFolder> rtn = new List <MgaFolder>();
rtn.Add(folder);
foreach (MgaFolder subfolder in folder.ChildFolders)
{
rtn.AddRange(getAllFolders(subfolder));
}
return(rtn);
}
public void migrateProject()
{
RootFolder = project.RootFolder;
RootModel = null;
List<MgaFolder> folders = getAllFolders(project.RootFolder);
List<MgaFolder> C = new List<MgaFolder>(); //components
List<MgaFolder> DS = new List<MgaFolder>(); //design spaces
List<MgaFolder> CA = new List<MgaFolder>(); // component assemblies
List<MgaFolder> TC = new List<MgaFolder>(); //test components
List<MgaFolder> T = new List<MgaFolder>(); //testing
List<MgaFolder> other = new List<MgaFolder>();
foreach (MgaFolder folder in folders)
{
if (folder == null)
continue;
if (folder.MetaFolder.DisplayedName == "Components")
C.Add(folder);
else if (folder.MetaFolder.DisplayedName == "Design Spaces")
DS.Add(folder);
else if (folder.MetaFolder.DisplayedName == "Component Assemblies")
CA.Add(folder);
else if (folder.MetaFolder.DisplayedName == "Test Components")
TC.Add(folder);
else if (folder.MetaFolder.DisplayedName == "Testing")
T.Add(folder);
else
other.Add(folder);
}
foreach (MgaFolder folder in C)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
foreach (MgaFolder folder in DS)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
foreach (MgaFolder folder in CA)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
foreach (MgaFolder folder in TC)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
foreach (MgaFolder folder in T)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
foreach (MgaFolder folder in other)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
private static MgaFolder GetLibraryRoot(MgaFolder mgaFolder)
{
Contract.Requires(mgaFolder != null);
if (mgaFolder.MetaBase.Name == "RootFolder")
{
return(mgaFolder);
}
else
{
return(GetLibraryRoot(mgaFolder.ParentFolder));
}
}
private void CollapseFolders(MgaFolder mgaFolder)
{
Func <IMgaObject, Tuple <string, string> > nameAndKind = x => new Tuple <string, string>(x.Name, x.MetaBase.Name);
var uniqueNames = mgaFolder
.ChildFolders
.Cast <MgaFolder>()
.Where(x => x.IsLibOrLibObject() == false)
.Where(x => x.MetaBase.Name != "RootFolder")
.GroupBy(x => nameAndKind(x))
.ToList();
foreach (var group in uniqueNames.Where(x => x.Any()))
{
var firstObj = group.First();
var foldersToMove = group.Skip(1).SelectMany(x => x.ChildFolders.Cast <MgaFolder>()).Where(x => x.IsLibOrLibObject() == false);
var fcosToMove = group.Skip(1).SelectMany(x => x.ChildFCOs.Cast <MgaFCO>()).Where(x => x.IsLibObject == false);
//GMEConsole.Info.WriteLine(" -- {0}", firstObj.AbsPath);
foreach (var item in foldersToMove)
{
if (item.IsLibOrLibObject())
{
GMEConsole.Error.WriteLine(" - Lib object! {0}", item.AbsPath);
continue;
}
var moved = firstObj.MoveFolderDisp(item);
//GMEConsole.Info.WriteLine(" ----- {0} -> {1}", item.AbsPath, moved.AbsPath);
}
foreach (var item in fcosToMove)
{
if (item.IsLibObject)
{
GMEConsole.Error.WriteLine(" - Lib object! {0}", item.AbsPath);
continue;
}
var moved = firstObj.MoveFCODisp(item);
//GMEConsole.Info.WriteLine(" ----- {0} -> {1}", item.AbsPath, moved.AbsPath);
}
}
foreach (MgaFolder childFolder in mgaFolder.ChildFolders)
{
if (childFolder.IsLibOrLibObject() == false)
{
this.CollapseFolders(childFolder);
}
}
}
public void migrateFolder(MgaFolder rootfolder)
{
RootFolder = rootfolder;
RootModel = null;
List <MgaFolder> folders = getAllFolders(rootfolder);
foreach (MgaFolder folder in folders)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
private void CollapseLibraries(MgaFolder mgaFolder)
{
var libraries = mgaFolder
.ChildFolders
.Cast <MgaFolder>()
.Where(x => string.IsNullOrEmpty(x.LibraryName) == false)
.GroupBy(lib => libInfos.Where(inf => lib.Name.Contains(inf.DisplayName)).FirstOrDefault())
.ToList();
foreach (IGrouping <LibraryInfo, MgaFolder> group in libraries.Where(gr => gr.Key != null))
{
var orderedLibraries = group.OrderBy(f => f.RelID);
var library = orderedLibraries.First();
foreach (var dup in orderedLibraries.Skip(1))
{
ReferenceSwitcher.Switcher sw = new ReferenceSwitcher.Switcher(dup, library, null);
sw.UpdateSublibrary();
dup.DestroyObject();
}
}
}
private void CreateMaterialObjects(MgaFolder materialFolder,
List <string> materialsList)
{
List <string> existingMaterials = new List <string>();
foreach (MgaFCO item in materialFolder.ChildFCOs)
{
existingMaterials.Add(item.StrAttrByName["Name"]);
}
foreach (var materialName in materialsList)
{
if (!existingMaterials.Contains(materialName))
{
MgaMetaFCO role = (materialFolder.MetaFolder as MgaMetaFolder).get_LegalRootObjectByName("Material");
MgaFCO aMaterial = materialFolder.CreateRootObject(role);
aMaterial.Name = materialName;
aMaterial.StrAttrByName["Name"] = materialName;
}
}
}
private static MgaFCO GenerateTestModel(MgaProject project, MgaFCO currentobj)
{
MgaFolder folderComponentAssemblies = project.RootFolder.CreateFolder(project.RootMeta.RootFolder.DefinedFolderByName["ComponentAssemblies", true]);
folderComponentAssemblies.Name = "00 ComponentAssemblies";
MgaModel ca = folderComponentAssemblies.CreateRootObject(project.RootMeta.RootFolder.DefinedFCOByName["ComponentAssembly", true]) as MgaModel;
ca.Name = string.Format("00 Generated Component Assembly {0}", DateTime.Now);
MgaFolder folderComponents = project.RootFolder.CreateFolder(project.RootMeta.RootFolder.DefinedFolderByName["Components", true]);
folderComponents.Name = "00 Components";
MgaModel leaf = folderComponents.CreateRootObject(project.RootMeta.RootFolder.DefinedFCOByName["Component", true]) as MgaModel;
leaf.Name = string.Format("00 Generated Component {0}", DateTime.Now);
// generate syntetic model
GenerateAssemblies(folderComponentAssemblies, ca, 0, leaf);
currentobj = ca as MgaFCO;
return(currentobj);
}
private MgaFCO SurrogateMaster(
MgaProject project,
MgaFCO currentobj,
MgaFCOs selectedobjs,
int param,
bool expand = true)
{
MgaFolder f = currentobj.ParentFolder;
if (f == null)
{
throw new Exception("Testbench does not have a TestFolder parent!");
}
MgaFolder fNew = f.CreateFolder(f.MetaFolder);
fNew.Name = currentobj.Name + DateTime.Now.ToString(" (MM-dd-yyyy HH:mm:ss)");
MgaFCO newTestbench = fNew.CopyFCODisp(currentobj);
//newTestbench.Name += " TestName";
return(newTestbench);
}
public void Main(MgaProject project, MgaFCO currentobj, MgaFCOs selectedobjs, ComponentStartMode startMode)
{
// TODO: Add your interpreter code
GMEConsole.Clear();
GMEConsole.Out.WriteLine("Running interpreter...");
// Get RootFolder
IMgaFolder rootFolder = project.RootFolder;
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "Json Files (*.json)|*.json";
var userClickedOK = openFileDialog1.ShowDialog();
// Process input if the user clicked OK.
if (userClickedOK == System.Windows.Forms.DialogResult.OK)
{
string fileName = openFileDialog1.FileName;
// parse Json
if (File.Exists(fileName))
{
List <string> materialKeys = new List <string>();
using (StreamReader reader = new StreamReader(fileName))
{
string materialStr = reader.ReadToEnd();
JObject o = JObject.Parse(materialStr);
JObject materialLib = o["Material library"].Value <JObject>();
if (materialLib != null)
{
materialKeys = materialLib.Properties().Select(p => p.Name).ToList();
}
}
// create material folders
if (materialKeys.Count() > 0)
{
int count = rootFolder.ChildFolders.OfType <GME.MGA.MgaFolder>().Where(f => f.MetaBase.Name == "MaterialsDefinition").Count();
if (count > 1)
{
GMEConsole.Error.WriteLine("There should only be 1 materials definition folder!");
return;
}
else if (count < 1)
{
var role = (rootFolder.MetaFolder as MgaMetaFolder).get_LegalChildFolderByName("MaterialsDefinition");
MgaFolder materialFolder = rootFolder.CreateFolder(role);
materialFolder.Name = "MaterialDefinitions";
CreateMaterialObjects(materialFolder,
materialKeys);
}
else
{
MgaFolder materialFolder = rootFolder.ChildFolders.OfType <GME.MGA.MgaFolder>().Where(f => f.MetaBase.Name == "MaterialsDefinition").First();
CreateMaterialObjects(materialFolder,
materialKeys);
}
}
}
}
else
{
return;
}
// To use the domain-specific API:
// Create another project with the same name as the paradigm name
// Copy the paradigm .mga file to the directory containing the new project
// In the new project, install the GME DSMLGenerator NuGet package (search for DSMLGenerator)
// Add a Reference in this project to the other project
// Add "using [ParadigmName] = ISIS.GME.Dsml.[ParadigmName].Classes.Interfaces;" to the top of this file
// if (currentobj.Meta.Name == "KindName")
// [ParadigmName].[KindName] dsCurrentObj = ISIS.GME.Dsml.[ParadigmName].Classes.[KindName].Cast(currentobj);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent"></param>
/// <param name="metaRef">meta ref of the new object</param>
/// <param name="roleMetaRef">meta ref of the role (if the parent is a model)</param>
/// <returns></returns>
public static T CreateObject <T>(
ISIS.GME.Common.Interfaces.Container parent,
int metaRef,
int roleMetaRef = 0)
where T : ISIS.GME.Common.Classes.Base, new()
{
Contract.Requires(parent != null);
T result = new T();
if (parent.Impl is MgaModel)
{
MgaModel model = parent.Impl as MgaModel;
MgaMetaRole role = null;
try
{
// try to use user defined role
role = (model.MetaBase as MgaMetaModel).
Roles.
Cast <MgaMetaRole>().
FirstOrDefault(x => x.MetaRef == roleMetaRef);
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Role was not found in the container.");
sb.AppendLine("Paradigm violation.");
sb.AppendFormat("Container type: {0} Requested role: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
try
{
IMgaFCO fco = model.CreateChildObject(role);
result.Impl = fco as IMgaObject;
return(result);
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("New element could not be created.");
sb.AppendFormat("Container type: {0} Requested role: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
}
else if (parent.Impl is MgaFolder)
{
try
{
MgaFolder folder = parent.Impl as MgaFolder;
MgaMetaFolder item = folder.MetaFolder.
LegalChildFolders.
Cast <MgaMetaFolder>().
FirstOrDefault(x => x.MetaRef == metaRef);
if (item != null)
{
// create new folder
MgaFolder f = folder.CreateFolder(item);
result.Impl = f as IMgaObject;
return(result);
}
else
{
MgaMetaFCO itemFco = folder.MetaFolder.
LegalRootObjects.
Cast <MgaMetaFCO>().
FirstOrDefault(x => x.MetaRef == metaRef);
if (itemFco != null)
{
IMgaFCO f = folder.CreateRootObject(itemFco);
result.Impl = f as IMgaObject;
return(result);
}
}
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("New element could not be created in folder.");
sb.AppendFormat("Container type: {0} Requested child type: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
}
return(null);
}
public void migrateProject()
{
RootFolder = project.RootFolder;
RootModel = null;
List <MgaFolder> folders = getAllFolders(project.RootFolder);
List <MgaFolder> C = new List <MgaFolder>(); //components
List <MgaFolder> DS = new List <MgaFolder>(); //design spaces
List <MgaFolder> CA = new List <MgaFolder>(); // component assemblies
List <MgaFolder> TC = new List <MgaFolder>(); //test components
List <MgaFolder> T = new List <MgaFolder>(); //testing
List <MgaFolder> other = new List <MgaFolder>();
foreach (MgaFolder folder in folders)
{
if (folder == null)
{
continue;
}
if (folder.MetaFolder.DisplayedName == "Components")
{
C.Add(folder);
}
else if (folder.MetaFolder.DisplayedName == "Design Spaces")
{
DS.Add(folder);
}
else if (folder.MetaFolder.DisplayedName == "Component Assemblies")
{
CA.Add(folder);
}
else if (folder.MetaFolder.DisplayedName == "Test Components")
{
TC.Add(folder);
}
else if (folder.MetaFolder.DisplayedName == "Testing")
{
T.Add(folder);
}
else
{
other.Add(folder);
}
}
foreach (MgaFolder folder in C)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
foreach (MgaFolder folder in DS)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
foreach (MgaFolder folder in CA)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
foreach (MgaFolder folder in TC)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
foreach (MgaFolder folder in T)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
foreach (MgaFolder folder in other)
{
foreach (MgaModel model in folder.ChildObjects.OfType <MgaModel>())
{
createNewFCOs(model);
}
}
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
private void RemoveEmptyDuplicatedFolders(MgaFolder mgaFolder)
{
foreach (MgaFolder childFolder in mgaFolder.ChildFolders)
{
if (childFolder.IsLibOrLibObject() == false)
{
this.RemoveEmptyDuplicatedFolders(childFolder);
}
}
var uniqueNames = mgaFolder
.ChildFolders
.Cast<MgaFolder>()
.Where(x => x.IsLibOrLibObject() == false)
.Select(x => x.Name)
.Distinct()
.ToList();
foreach (var uniqueFolderName in uniqueNames)
{
var firstObj = mgaFolder.ChildFolders.Cast<MgaFolder>().Where(x => x.IsLibOrLibObject() == false).Where(x => x.Name == uniqueFolderName).FirstOrDefault();
var foldersToDelete = mgaFolder.ChildFolders.Cast<MgaFolder>().Where(x => x.IsLibOrLibObject() == false).Where(x => x != firstObj).Where(x => x.Name == uniqueFolderName).Where(x => x.ChildObjects.Count == 0).ToList();
foldersToDelete.ForEach(x => x.DestroyObject());
}
}
public static bool IsLibOrLibObject(this MgaFolder o)
{
return(IsLibOrLibObject(((IMgaObject)o)));
}
private List<MgaFolder> getAllFolders(MgaFolder folder)
{
List<MgaFolder> rtn = new List<MgaFolder>();
rtn.Add(folder);
foreach (MgaFolder subfolder in folder.ChildFolders)
rtn.AddRange(getAllFolders(subfolder));
return rtn;
}
public void migrateModel(MgaModel rootmodel)
{
RootFolder = null;
RootModel = rootmodel;
createNewFCOs(rootmodel);
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
// Your basic recursive folder-gatherer.
private List<MgaFolder> RecursivelyGetAllFolders(MgaFolder folder)
{
List<MgaFolder> rtn = new List<MgaFolder>();
if (folder.MetaBase.Name == "RootFolder")
{
GMEConsole.Info.WriteLine(
"Omitted {0} - it is a RootFolder and contains no valid models",
folder.Name);
}
else
{
rtn.Add(folder);
}
foreach (MgaFolder subfolder in folder.ChildFolders)
rtn.AddRange(RecursivelyGetAllFolders(subfolder));
return rtn;
}
private static void GenerateAssemblies(MgaFolder componentAssemblyFolder, MgaModel assembly, int level, MgaModel leaf)
{
var elementsOnEachLevel = 2;
var numberOfLevels = 6;
if (level <= numberOfLevels)
{
System.Console.Out.WriteLine(level);
MgaFolder componentAssemblyChildFolder = componentAssemblyFolder.CreateFolder(componentAssemblyFolder.Project.RootMeta.RootFolder.DefinedFolderByName["ComponentAssemblies", true]);
componentAssemblyChildFolder.Name = string.Format("ComponentAssembly Child folder {0}", level);
for (int i = 0; i < elementsOnEachLevel; i++)
{
var childAssembly = componentAssemblyChildFolder.CreateRootObject(assembly.Meta) as MgaModel;
childAssembly.Name = string.Format("ChildAssembly {0} {1}", level, i);
var cref = assembly.CreateChildObject((assembly.Meta as GME.MGA.Meta.MgaMetaModel).RoleByName["ComponentRef"]) as MgaReference;
cref.Name = string.Format("ComponentRef {0} {1}", level, i);
if (level < numberOfLevels)
{
cref.Referred = childAssembly as MgaFCO;
GenerateAssemblies(componentAssemblyFolder, childAssembly, level + 1, leaf);
}
else
{
cref.Referred = leaf as MgaFCO;
}
}
}
}
public static T CreateObject <T>(
ISIS.GME.Common.Interfaces.Container parent,
string roleStr = null)
where T : ISIS.GME.Common.Classes.Base, new()
{
Contract.Requires(parent != null);
T result = new T();
string Kind = typeof(T).Name;
if (parent.Impl is IMgaModel)
{
IMgaModel model = parent.Impl as IMgaModel;
MgaMetaRole role = null;
if (string.IsNullOrEmpty(roleStr))
{
try
{
// try to use user defined role
role = (model.MetaBase as IMgaMetaModel).RoleByName[Kind];
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Role was not found in the container.");
sb.AppendLine("Paradigm violation.");
sb.AppendFormat("Container type: {0} Requested role: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
}
else
{
try
{
// try to use user defined role
role = (model.MetaBase as IMgaMetaModel).RoleByName[roleStr];
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Role was not found in the container.");
sb.AppendLine("Paradigm violation.");
sb.AppendFormat("Container type: {0} Requested role: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
}
try
{
MgaFCO fco = model.CreateChildObject(role);
result.Impl = fco as IMgaObject;
return(result);
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("New element could not be created.");
sb.AppendFormat("Container type: {0} Requested role: {1}",
parent.Kind,
result.GetType().Name);
throw new Exception(sb.ToString(), ex);
}
}
else if (parent.Impl is MgaFolder)
{
if (string.IsNullOrEmpty(roleStr))
{
MgaFolder folder = parent.Impl as MgaFolder;
foreach (MgaMetaFolder item in folder.MetaFolder.LegalChildFolders)
{
if (item.Name == Kind)
{
MgaFolder f = folder.CreateFolder(item);
result.Impl = f as IMgaObject;
return(result);
}
}
if (result.Impl == null)
{
foreach (MgaMetaFCO item in folder.MetaFolder.LegalRootObjects)
{
if (item.Name == Kind)
{
IMgaFCO fco = folder.CreateRootObject(item);
result.Impl = fco as IMgaObject;
return(result);
}
}
}
}
else
{
MgaFolder folder = parent.Impl as MgaFolder;
foreach (MgaMetaFolder item in folder.MetaFolder.LegalChildFolders)
{
if (item.Name == roleStr)
{
MgaFolder f = folder.CreateFolder(item);
result.Impl = f as IMgaObject;
return(result);
}
}
if (result.Impl == null)
{
foreach (MgaMetaFCO item in folder.MetaFolder.LegalRootObjects)
{
if (item.Name == roleStr)
{
IMgaFCO fco = folder.CreateRootObject(item);
result.Impl = fco as IMgaObject;
return(result);
}
}
}
}
}
return(null);
}
public MgaMetaFCO GetKindByStrDisp(MgaFolder parent, string kindname, objtype_enum objtype)
{
return(delegate_.GetKindByStrDisp(parent, kindname, objtype));
}
private bool willBeMigrated(MgaFolder folder)
{
if (folder == RootFolder)
return true;
return folder.ParentFolder != null && willBeMigrated(folder.ParentFolder);
}
public MgaMetaFolder GetFolderByStrDisp(MgaFolder parent, string kindname)
{
return(delegate_.GetFolderByStrDisp(parent, kindname));
}
public MgaMetaFCO get_KindByStr(MgaFolder parent, string kindname, objtype_enum objtype)
{
return(delegate_.KindByStr[parent, kindname, objtype]);
}
private void CollapseLibraries(MgaFolder mgaFolder)
{
var libraries = mgaFolder
.ChildFolders
.Cast<MgaFolder>()
.Where(x => string.IsNullOrEmpty(x.LibraryName) == false)
.GroupBy(lib => libInfos.Where(inf => lib.Name.Contains(inf.DisplayName)).FirstOrDefault())
.ToList();
foreach (IGrouping<LibraryInfo, MgaFolder> group in libraries.Where(gr => gr.Key != null))
{
var orderedLibraries = group.OrderBy(f => f.RelID);
var library = orderedLibraries.First();
foreach (var dup in orderedLibraries.Skip(1))
{
ReferenceSwitcher.Switcher sw = new ReferenceSwitcher.Switcher(dup, library, null);
sw.UpdateSublibrary();
dup.DestroyObject();
}
}
}
private IEnumerable<CyPhy.ComponentAssembly> GetAllComponentAssemblys(IMgaProject project, bool includeLibraries = false)
{
var filter = project.CreateFilter();
filter.Kind = "ComponentAssembly";
int componentsId = project.RootMeta.RootFolder.GetDefinedFolderByNameDisp("Components", true).MetaRef;
int componentAssembliesId = project.RootMeta.RootFolder.GetDefinedFolderByNameDisp("ComponentAssemblies", true).MetaRef;
IEnumerable<MgaFolder> rootFolders = new MgaFolder[] { project.RootFolder };
if (includeLibraries)
{
rootFolders = rootFolders.Concat(
project.RootFolder.ChildFolders.Cast<MgaFolder>().Where(f => String.IsNullOrEmpty(f.LibraryName) == false));
}
foreach (MgaFolder rootFolder in rootFolders)
{
foreach (MgaFolder folder in rootFolder.ChildFolders)
{
int metaRef = folder.MetaBase.MetaRef;
if (metaRef == componentsId || metaRef == componentAssembliesId)
{
foreach (IMgaObject fco in folder.GetDescendantFCOs(filter))
{
yield return CyPhyClasses.ComponentAssembly.Cast(fco);
}
}
}
}
}
private void CollapseFolders(MgaFolder mgaFolder)
{
Func<IMgaObject, Tuple<string, string>> nameAndKind = x => new Tuple<string, string>(x.Name, x.MetaBase.Name);
var uniqueNames = mgaFolder
.ChildFolders
.Cast<MgaFolder>()
.Where(x => x.IsLibOrLibObject() == false)
.Where(x => x.MetaBase.Name != "RootFolder")
.GroupBy(x => nameAndKind(x))
.ToList();
foreach (var group in uniqueNames.Where(x => x.Any()))
{
var firstObj = group.First();
var foldersToMove = group.Skip(1).SelectMany(x => x.ChildFolders.Cast<MgaFolder>()).Where(x => x.IsLibOrLibObject() == false);
var fcosToMove = group.Skip(1).SelectMany(x => x.ChildFCOs.Cast<MgaFCO>()).Where(x => x.IsLibObject == false);
//GMEConsole.Info.WriteLine(" -- {0}", firstObj.AbsPath);
foreach (var item in foldersToMove)
{
if (item.IsLibOrLibObject())
{
GMEConsole.Error.WriteLine(" - Lib object! {0}", item.AbsPath);
continue;
}
var moved = firstObj.MoveFolderDisp(item);
//GMEConsole.Info.WriteLine(" ----- {0} -> {1}", item.AbsPath, moved.AbsPath);
}
foreach (var item in fcosToMove)
{
if (item.IsLibObject)
{
GMEConsole.Error.WriteLine(" - Lib object! {0}", item.AbsPath);
continue;
}
var moved = firstObj.MoveFCODisp(item);
//GMEConsole.Info.WriteLine(" ----- {0} -> {1}", item.AbsPath, moved.AbsPath);
}
}
foreach (MgaFolder childFolder in mgaFolder.ChildFolders)
{
if (childFolder.IsLibOrLibObject() == false)
{
this.CollapseFolders(childFolder);
}
}
}
public MgaMetaFolder get_FolderByStr(MgaFolder parent, string kindname)
{
return(delegate_.FolderByStr[parent, kindname]);
}
public void migrateFolder(MgaFolder rootfolder)
{
RootFolder = rootfolder;
RootModel = null;
List<MgaFolder> folders = getAllFolders(rootfolder);
foreach (MgaFolder folder in folders)
foreach (MgaModel model in folder.ChildObjects.OfType<MgaModel>())
createNewFCOs(model);
directFCOs();
copyOldLayout();
deleteOldFCOs();
}
private void CreateMaterialObjects(MgaFolder materialFolder,
List<string> materialsList)
{
List<string> existingMaterials = new List<string>();
foreach (MgaFCO item in materialFolder.ChildFCOs)
{
existingMaterials.Add(item.StrAttrByName["Name"]);
}
foreach (var materialName in materialsList)
{
if (!existingMaterials.Contains(materialName))
{
MgaMetaFCO role = (materialFolder.MetaFolder as MgaMetaFolder).get_LegalRootObjectByName("Material");
MgaFCO aMaterial = materialFolder.CreateRootObject(role);
aMaterial.Name = materialName;
aMaterial.StrAttrByName["Name"] = materialName;
}
}
}
