public bool TryGetTag <T>(string name, out CachedTag result) where T : TagStructure
{
if (name == "none" || name == "null")
{
result = null;
return(true);
}
if (Tags.TagDefinition.Types.Values.Contains(typeof(T)))
{
var groupTag = Tags.TagDefinition.Types.First((KeyValuePair <Tag, Type> entry) => entry.Value == typeof(T)).Key;
foreach (var instance in TagCache.TagTable)
{
if (instance is null)
{
continue;
}
if (instance.IsInGroup(groupTag) && instance.Name == name)
{
result = instance;
return(true);
}
}
}
result = null;
return(false);
}
public override object Deserialize(Stream stream, CachedTag instance)
{
var definitionType = TagDefinition.Find(instance.Group);
var context = new ModPackageTagSerializationContext(stream, this, BaseModPackage, (CachedTagHaloOnline)instance);
return(Deserializer.Deserialize(context, definitionType));
}
public override void Serialize(Stream stream, CachedTag instance, object definition)
{
if (typeof(CachedTagGen2) == instance.GetType())
{
Serialize(stream, (CachedTagGen2)instance, definition);
}
else
{
throw new Exception($"Try to serialize a {instance.GetType()} into a Gen 3 Game Cache");
}
}
// Utilities, I believe they don't belong here but I haven't found a better solution yet. I think GroupTag should store the string,
// not the stringid, therefore we could hardcode the list of tag group types
public bool TryGetCachedTag(int index, out CachedTag instance)
{
if (index < 0 || index >= TagCache.TagTable.Count())
{
instance = null;
return(false);
}
instance = TagCache.GetTag(index);
return(true);
}
public bool TryAllocateTag(out CachedTag result, Type type, string name = null)
{
result = null;
try
{
var structure = TagStructure.GetTagStructureInfo(type, Version).Structure;
if (structure == null)
{
Console.WriteLine($"TagStructure attribute not found for type \"{type.Name}\".");
return(false);
}
var groupTag = new Tag(structure.Tag);
if (!TagGroup.Instances.ContainsKey(groupTag))
{
Console.WriteLine($"TagGroup not found for type \"{type.Name}\" ({structure.Tag}).");
return(false);
}
result = AllocateTag(TagGroup.Instances[groupTag], name);
if (result == null)
{
return(false);
}
}
catch (Exception e)
{
Console.WriteLine($"{e.GetType().Name}: {e.Message}");
return(false);
}
return(true);
}
public override object Deserialize(Stream stream, CachedTag instance) => Deserialize(new Gen2SerializationContext(stream, this, (CachedTagGen2)instance), TagDefinition.Find(instance.Group.Tag));
public override T Deserialize <T>(Stream stream, CachedTag instance) => Deserialize <T>(new Gen2SerializationContext(stream, this, (CachedTagGen2)instance));
private ISerializationContext CreateTagSerializationContext(Stream stream, CachedTag instance)
{
return(new ModPackageTagSerializationContext(stream, this, BaseModPackage, (CachedTagHaloOnline)instance));
}
public override void Serialize(Stream stream, CachedTag instance, object definition)
{
Serializer.Serialize(CreateTagSerializationContext(stream, instance), definition);
}
public override T Deserialize <T>(Stream stream, CachedTag instance)
{
return(Deserializer.Deserialize <T>(CreateTagSerializationContext(stream, instance)));
}
public override T Deserialize <T>(Stream stream, CachedTag instance) => Deserialize <T>(new HaloOnlineSerializationContext(stream, this, (CachedTagHaloOnline)instance));
public abstract T Deserialize <T>(Stream stream, CachedTag instance);
public abstract object Deserialize(Stream stream, CachedTag instance);
public abstract void Serialize(Stream stream, CachedTag instance, object definition);
public bool TryGetTag(string name, out CachedTag result)
{
if (name.Length == 0)
{
result = null;
return(false);
}
if (name == "null")
{
result = null;
return(true);
}
if (name == "*")
{
if (TagCache.Count == 0)
{
result = null;
return(false);
}
result = TagCache.TagTable.Last();
return(true);
}
if (name.StartsWith("*."))
{
if (!name.TrySplit('.', out var startNamePieces) || !TryParseGroupTag(startNamePieces[1], out var starGroupTag))
{
result = null;
return(false);
}
result = TagCache.TagTable.Last(tag => tag != null && tag.IsInGroup(starGroupTag));
return(true);
}
if (name.StartsWith("0x"))
{
name = name.Substring(2);
if (name.TrySplit('.', out var hexNamePieces))
{
name = hexNamePieces[0];
}
if (!int.TryParse(name, NumberStyles.HexNumber, null, out int tagIndex) || (TagCache.GetTag(tagIndex) == null))
{
result = null;
return(false);
}
result = TagCache.GetTag(tagIndex);
return(true);
}
if (!name.TrySplit('.', out var namePieces) || !TryParseGroupTag(namePieces[namePieces.Length - 1], out var groupTag))
{
throw new Exception($"Invalid tag name: {name}");
}
//var tagName = namePieces[0];
var tagName = name.Substring(0, name.Length - (1 + namePieces[namePieces.Length - 1].Length));
foreach (var instance in TagCache.TagTable)
{
if (instance is null)
{
continue;
}
if (instance.IsInGroup(groupTag) && instance.Name == tagName)
{
result = instance;
return(true);
}
}
result = null;
return(false);
}
