public SubClassFieldViewModel(ISubClassBase parent, GenDataDefSubClass genDataDefSubClass, ISubClassBase subClass,
SubClassField subClassField, bool isReadOnly)
{
IgnorePropertyValidation = true;
Parent = parent;
GenDataDefSubClass = genDataDefSubClass;
SubClassField = subClassField;
SubClass = subClass;
switch (subClassField)
{
case SubClassField.Name:
Name = "Name";
Hint = genDataDefSubClass == null || genDataDefSubClass.Reference == ""
? "The name of the subclass"
: "The name of the top level class in the referenced file";
DataType = "Identifier";
IsReadOnly = true;
break;
case SubClassField.Reference:
Name = "Reference";
Hint = genDataDefSubClass == null || genDataDefSubClass.Reference == ""
? "Must be blank"
: "The name of the referenced file";
DataType = "String";
IsReadOnly = isReadOnly || genDataDefSubClass == null || genDataDefSubClass.Reference == "";
break;
default:
throw new ArgumentOutOfRangeException("subClassField");
}
}
public SubClassReference(GenDataBase genDataBase, GenObject parent, int classId, GenDataDefSubClass subClassDef)
{
GenDataBase = genDataBase;
Definition = subClassDef;
ClassId = classId;
Parent = parent;
}
private static void ParseReference(string reference, GenDataDefSubClass sc)
{
sc.Reference = reference;
var ra = reference.Split(':');
sc.ReferenceDefinition = ra[0];
}
public SubClassViewModel(ISubClassBase parent, ISubClassBase subClassBase,
GenNamedApplicationBase def, GenDataDefSubClass subClassDef, bool isReadOnly)
{
Parent = parent;
Definition = def;
SubClassDef = subClassDef;
IsReadOnly = isReadOnly;
// SavedContext = savedContext;
SubClassBase = subClassBase;
SavedReference = Parent != null ? Parent.Reference : "";
GenObject = subClassBase.Parent;
}
private void AddSubClass(GenDataDefSubClass subClassDef, GenDataBase genDataBase)
{
var subClassClassDef = subClassDef.SubClass;
if (string.IsNullOrEmpty(subClassDef.ReferenceDefinition))
{
Add(new GenSubClass(genDataBase, Parent, subClassClassDef.ClassId, subClassDef));
}
else
{
Add(new SubClassReference(genDataBase, Parent, subClassClassDef.ClassId, subClassDef));
}
}
/// <summary>
/// Create a new <see cref="GenObjectList"/> list.
/// </summary>
/// <param name="data">The generator data containing the list.</param>
/// <param name="parent">The generator object owning the list.</param>
/// <param name="classId">The ID of objects in the list.</param>
/// <param name="subClassDef">The definition of the subclass</param>
public GenSubClass(GenDataBase data, GenObject parent, int classId, GenDataDefSubClass subClassDef)
{
Properties = new NameList {
"Reference", "Relationship"
};
Attributes = new TextList {
"", ""
};
Reference = "";
Definition = subClassDef;
GenDataBase = data;
Parent = parent;
ClassId = classId;
}
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;
}
}
}
}
