private void AddInheritedSubClasses(GenDataDefClass parentDef, GenDataBase genDataBase)
{
if (parentDef != null && parentDef.IsInherited)
{
AddInheritedSubClasses(parentDef.Parent, genDataBase);
AddSubClasses(parentDef.Parent, genDataBase);
}
}
private void AddSubClasses(GenDataDefClass parentDef, GenDataBase genDataBase)
{
if (parentDef != null)
{
foreach (var t in parentDef.SubClasses)
{
AddSubClass(t, genDataBase);
}
}
}
public void AddInheritor(string className, string inheritorName)
{
var i = GetClassId(className);
var j = GetClassId(inheritorName);
GenDataDefClass inheritor;
if (j == -1)
{
inheritor = new GenDataDefClass
{
Name = inheritorName,
ClassId = Classes.Count,
Definition = Definition.ClassList.Find(inheritorName)
};
Classes.Add(inheritor);
}
else
{
inheritor = Classes[j];
}
var parent = Classes[i];
if (!parent.Inheritors.Contains(inheritorName))
{
parent.Inheritors.Add(inheritor);
inheritor.Parent = parent;
inheritor.IsInherited = true;
for (var k = 0; k < parent.InstanceProperties.Count; k++)
{
if (inheritor.InstanceProperties.IndexOf(parent.Properties[k]) == -1)
{
inheritor.AddInstanceProperty(parent.Properties[k]);
}
}
}
}
private GenSubClass GetSubClassByIndex(int subClassId, int idx, GenDataDefClass subClassDef)
{
var subClassRef = SubClass[idx] as SubClassReference;
if (subClassRef != null)
{
if (String.IsNullOrEmpty(subClassRef.Reference))
{
return(GenSubClass.Empty);
}
var d = GenDataBase.CheckReference(subClassRef.Definition.Reference, subClassRef.Reference);
foreach (var o in d.Root.SubClass[0])
{
o.RefParent = this;
}
return((GenSubClass)d.Root.SubClass[0]);
}
var subClass = (GenSubClass)SubClass[idx];
if (subClass.ClassId == subClassId)
{
return(subClass);
}
var newSubClass = new GenSubClass(GenDataBase, Parent, subClassId, subClass.Definition);
foreach (var o in subClass)
{
if (subClassDef.IsInheritor(o.ClassId))
{
newSubClass.Add(o);
}
}
return(newSubClass);
}
public void AddSubClass(string className, string subClassName, string reference)
{
AddSubClass(className, subClassName);
if (string.IsNullOrEmpty(reference))
{
return;
}
var i = GetClassId(className);
var j = Classes[i].SubClasses.IndexOf(subClassName);
var sc = Classes[i].SubClasses[j];
sc.SubClass.CreateInstanceProperties();
ParseReference(reference, sc);
if (!Cache.Contains(sc.ReferenceDefinition))
{
Cache[sc.ReferenceDefinition] = sc.ReferenceDefinition.Equals("minimal",
StringComparison
.InvariantCultureIgnoreCase)
? CreateMinimal()
: GenDataBase.DataLoader.LoadData(sc.ReferenceDefinition).AsDef();
}
var rf = Cache[sc.ReferenceDefinition];
for (var k = 1; k < rf.Classes.Count; k++)
{
var item = rf.Classes[k];
if (!Classes.Contains(rf.Classes[k].Name))
{
var newClass = new GenDataDefClass
{
Name = item.Name,
Parent = item.Parent,
ClassId = Classes.Count,
Definition = item.Definition,
IsReference = true,
IsInherited = item.IsInherited,
RefClassId = item.ClassId,
RefDef = rf,
Reference = sc.Reference,
ReferenceDefinition = sc.ReferenceDefinition
};
foreach (var instanceProperty in item.InstanceProperties)
{
newClass.AddInstanceProperty(instanceProperty);
}
Classes.Add(newClass);
}
else
{
var oldItem = Classes[GetClassId(item.Name)];
oldItem.IsReference = true;
oldItem.RefClassId = item.ClassId;
oldItem.RefDef = rf;
oldItem.Reference = sc.Reference;
oldItem.ReferenceDefinition = sc.ReferenceDefinition;
oldItem.IsInherited = item.IsInherited;
foreach (var instanceProperty in item.InstanceProperties)
{
oldItem.AddInstanceProperty(instanceProperty);
}
}
}
for (var k = 1; k < rf.Classes.Count; k++)
{
var item = rf.Classes[k];
if (item.SubClasses.Count != 0)
{
var refItem = Classes[GetClassId(item.Name)];
for (var l = 0; l < item.SubClasses.Count; l++)
{
var sub = item.SubClasses[l];
var classId = GetClassId(sub.SubClass.Name);
var found = false;
for (var m = 0; m < refItem.SubClasses.Count; m++)
{
if (refItem.SubClasses[m].SubClass.ClassId != classId)
{
continue;
}
found = true;
break;
}
if (found)
{
continue;
}
var newSub = new GenDataDefSubClass
{
Reference = sc.Reference,
ReferenceDefinition = sc.ReferenceDefinition,
SubClass = Classes[classId]
};
refItem.SubClasses.Add(newSub);
newSub.SubClass.Parent = refItem;
}
}
if (item.Inheritors.Count != 0)
{
var refItem = Classes[GetClassId(item.Name)];
for (var l = 0; l < item.Inheritors.Count; l++)
{
var inheritor = item.Inheritors[l];
var classId = GetClassId(inheritor.Name);
var found = false;
for (var m = 0; m < refItem.Inheritors.Count; m++)
{
if (refItem.Inheritors[m].ClassId != classId)
{
continue;
}
found = true;
break;
}
if (found)
{
continue;
}
refItem.Inheritors.Add(Classes[classId]);
Classes[classId].Parent = refItem;
}
}
}
}
