private static ObjectFileDefinition LoadObjectFileDefinition(Raw.ObjectFileDefinition raw,
HashedDefinitionDictionary <ClassDefinition>
classDefs)
{
if (string.IsNullOrEmpty(raw.Name) == true)
{
throw new LoadException("binary object file missing name?");
}
ClassDefinition classDef = null;
if (raw.Object != null)
{
classDef = ClassDefinitionLoader.LoadClass(raw.Object, classDefs);
}
return(new ObjectFileDefinition()
{
Name = raw.Name,
Aliases =
new ReadOnlyCollection <string>(
new[] { raw.Name.ToLowerInvariant() }.Concat(raw.Aliases.Select(a => a.ToLowerInvariant()))
.Distinct()
.ToList()),
Object = classDef,
});
}
public static ClassDefinition LoadAnonymousClass(Raw.ClassDefinition raw,
HashedDefinitionDictionary <ClassDefinition> root)
{
var def = new ClassDefinition();
LoadClass(def, raw, root);
return(def);
}
public static ClassDefinition LoadClass(Raw.ClassDefinition raw,
HashedDefinitionDictionary <ClassDefinition> root)
{
var def = GetClass(raw);
LoadClass(def, raw, root);
return(def);
}
private static IList <FriendDefinition> LoadFriends(IEnumerable <Raw.FriendDefinition> raws,
HashedDefinitionDictionary <ClassDefinition> root)
{
var defs = new List <FriendDefinition>();
if (raws != null)
{
defs.AddRange(raws.Select(raw => LoadFriend(raw, root)));
}
return(defs);
}
private static void LoadClass(ClassDefinition def,
Raw.ClassDefinition raw,
HashedDefinitionDictionary <ClassDefinition> root)
{
def.Friends = new ReadOnlyCollection <FriendDefinition>(LoadFriends(raw.Friends, root));
def.Fields = new ReadOnlyCollection <FieldDefinition>(LoadFields(raw.Fields));
def.Objects = new ReadOnlyCollection <ClassDefinition>(LoadObjects(raw.Objects, root));
def.DynamicNestedClasses = raw.DynamicNestedClasses;
def.ClassFieldName = raw.ClassFieldName;
def.ClassFieldHash = raw.ClassFieldHash;
}
private static FriendDefinition LoadFriend(Raw.FriendDefinition raw,
HashedDefinitionDictionary <ClassDefinition> root)
{
if (root.ContainsKey(raw.Name) == false)
{
throw new LoadException(string.Format("could not find object '{0}'",
raw.Name));
}
return(new FriendDefinition()
{
Class = root[raw.Name],
ConditionField = raw.ConditionField,
ConditionValue = raw.ConditionValue,
ConditionType = raw.ConditionType,
});
}
private static IList <ClassDefinition> LoadObjects(IEnumerable <Raw.ClassDefinition> raws,
HashedDefinitionDictionary <ClassDefinition> root)
{
var defs = new List <ClassDefinition>();
if (raws != null)
{
foreach (var raw in raws)
{
var def = LoadClass(raw, root);
if (defs.Any(fd => fd.Hash == def.Hash))
{
throw new LoadException(string.Format("duplicate object '{0}'",
def.Name));
}
defs.Add(def);
}
}
return(defs);
}
public static NamedDefinitionDictionary <ObjectFileDefinition> Load(string basePath,
HashedDefinitionDictionary <ClassDefinition>
classDefs)
{
var raws = LoaderHelper.Load <Raw.ObjectFileDefinition>(GetObjectFilePaths(basePath));
var defs = new List <ObjectFileDefinition>();
var names = new List <string>();
foreach (var raw in raws)
{
if (raw.Aliases.Any(alias => names.Contains(alias) == true))
{
throw new LoadException(string.Format("duplicate binary object file '{0}'", raw.Name));
}
defs.Add(LoadObjectFileDefinition(raw, classDefs));
names.AddRange(raw.Aliases);
}
return(new NamedDefinitionDictionary <ObjectFileDefinition>(defs));
}
public static HashedDefinitionDictionary <ClassDefinition> Load(string basePath)
{
var raws = LoaderHelper.Load <Raw.ClassDefinition>(GetClassDefinitionPaths(basePath));
var pairs = new Dictionary <Raw.ClassDefinition, ClassDefinition>();
foreach (var raw in raws)
{
if (pairs.Any(d => d.Value.Name == raw.Name) == true)
{
throw new LoadException(string.Format("duplicate class '{0}'",
raw.Name));
}
pairs.Add(raw, GetClass(raw));
}
var defs = new HashedDefinitionDictionary <ClassDefinition>(pairs.Values);
foreach (var pair in pairs)
{
LoadClass(pair.Value, pair.Key, defs);
}
return(defs);
}
