private string CreateWriteMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled)
{
continue;
}
sb.Append(TAB);
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) || prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)))
{
//generate code which will convert identifier to unity object
Type mappedType = prop.MappedType.IsArray ? prop.MappedType.GetElementType() : prop.MappedType;
sb.AppendFormat("uo.{0} = FromId<{2}>({1});", prop.MappedName, prop.PersistentName, PrepareMappedTypeName(mappedType.Name));
}
else
{
sb.AppendFormat("uo.{0} = {1};", prop.MappedName, prop.PersistentName);
}
sb.Append(BR + TAB2);
}
return(sb.ToString());
}
/// <summary>
/// Generate method which will extract and populate context with dependencies (referenced unity objects)
/// </summary>
/// <param name="mapping"></param>
/// <returns></returns>
private string CreateDepsFromMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled)
{
continue;
}
if (prop.HasDependenciesOrIsDependencyItself)
{
if (prop.UseSurrogate)
{
sb.Append(TAB);
sb.AppendFormat("AddSurrogateDeps(uo.{0}, context);", prop.MappedName);
sb.Append(BR + TAB2);
}
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) || prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)))
{
sb.Append(TAB);
sb.AppendFormat("AddDep(uo.{0}, context);", prop.MappedName);
sb.Append(BR + TAB2);
}
}
}
return(sb.ToString());
}
private string CreateAddSubtypesBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
PersistentSubclass[] subclasses = mapping.Subclasses.Where(sc => sc.IsEnabled).ToArray();
for (int i = 0; i < subclasses.Length - 1; ++i)
{
PersistentSubclass subclass = mapping.Subclasses[i];
if (subclass.IsEnabled)
{
sb.Append(BR + TAB3 + TAB);
sb.AppendFormat(AddSubtypeTemplate, subclass.TypeName, subclass.PersistentTag + SubclassOffset);
}
}
if (subclasses.Length > 0)
{
if (mapping.Subclasses[subclasses.Length - 1].IsEnabled)
{
PersistentSubclass subclass = mapping.Subclasses[subclasses.Length - 1];
sb.Append(BR + TAB3 + TAB);
sb.AppendFormat(AddSubtypeTemplate, subclass.TypeName, subclass.PersistentTag + SubclassOffset);
}
}
return(sb.ToString());
}
private string CreateReadMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled)
{
continue;
}
sb.Append(TAB);
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) || prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)))
{
//generate code which will convert unity object to identifier
sb.AppendFormat("{0} = ToId(uo.{1});", prop.PersistentName, prop.MappedName);
}
else
{
sb.AppendFormat("{0} = uo.{1};", prop.PersistentName, prop.MappedName);
}
sb.Append(BR + TAB2);
}
return(sb.ToString());
}
private string CreateReadMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled || prop.HasPropertyInTemplate)
{
continue;
}
sb.Append(TAB);
string get = "uo.{1}";
if (prop.IsNonPublic)
{
get = "GetPrivate<" + prop.MappedTypeName + ">(uo, \"{1}\")";
}
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) ||
prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)) ||
IsGenericList(prop.MappedType) && prop.MappedType.GetGenericArguments()[0].IsSubclassOf(typeof(UnityObject)))
{
//generate code which will convert unity object to identifier
sb.AppendFormat("{0} = ToID(" + get + ");", prop.PersistentName, prop.MappedName);
}
else
{
if (prop.UseSurrogate)
{
if (IsGenericList(prop.MappedType))
{
sb.AppendFormat("{0} = Assign(" + get + ", v_ => ({2})v_);", prop.PersistentName, prop.MappedName, "Persistent" + prop.MappedType.GetGenericArguments()[0].Name);
}
else if (prop.MappedType.IsArray)
{
sb.AppendFormat("{0} = Assign(" + get + ", v_ => ({2})v_);", prop.PersistentName, prop.MappedName, "Persistent" + prop.MappedType.GetElementType().Name);
}
else
{
sb.AppendFormat("{0} = " + get + ";", prop.PersistentName, prop.MappedName);
}
}
else
{
sb.AppendFormat("{0} = " + get + ";", prop.PersistentName, prop.MappedName);
}
}
sb.Append(BR + TAB2);
}
return(sb.ToString());
}
private string CreateTypeModelCreatorBody(PersistentClassMapping[] mappings)
{
StringBuilder sb = new StringBuilder();
for (int m = 0; m < mappings.Length; ++m)
{
PersistentClassMapping mapping = mappings[m];
if (mapping == null)
{
continue;
}
if (!mapping.IsEnabled)
{
continue;
}
string endOfLine = string.Empty;
if (mapping.Subclasses != null && mapping.Subclasses.Where(s => s.IsEnabled).Count() > 0)
{
endOfLine = CreateAddSubtypesBody(mapping);
}
bool hasSurrogate = false;
Type mappingType = Type.GetType(mapping.MappedAssemblyQualifiedName);
if (mappingType == null)
{
Debug.LogWarning("Type " + mapping.MappedAssemblyQualifiedName + " was not found");
}
else
{
if (GetSurrogateType(mappingType) != null)
{
endOfLine += string.Format(SetSerializationSurrogate, PreparePersistentTypeName(mapping.PersistentTypeName));
hasSurrogate = true;
}
}
endOfLine += SEMICOLON + BR + TAB3;
if (hasSurrogate)
{
sb.AppendFormat(AddTypeTemplate, PrepareMappedTypeName(mapping.MappedTypeName), "false", endOfLine);
}
else if (mappingType != null)
{
if (mappingType.IsSubclassOf(typeof(UnityObject)) || mappingType == typeof(UnityObject) || mappingType == typeof(UnityEventBase))
{
sb.AppendFormat(AddTypeTemplate, PreparePersistentTypeName(mapping.PersistentTypeName), "true", endOfLine);
}
}
}
return(sb.ToString());
}
/// <summary>
/// Generate C# code of persistent class using persistent class mapping
/// </summary>
/// <param name="mapping"></param>
/// <returns></returns>
public string CreatePersistentClass(PersistentClassMapping mapping)
{
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
string usings = CreateUsings(mapping);
string ns = mapping.PersistentNamespace;
string className = PreparePersistentTypeName(mapping.PersistentTypeName);
string baseClassName = mapping.PersistentBaseTypeName != null?
PreparePersistentTypeName(mapping.PersistentBaseTypeName) : null;
string body = mapping.IsEnabled ? CreatePersistentClassBody(mapping) : string.Empty;
return(string.Format(PersistentClassTemplate, usings, ns, className, baseClassName, body));
}
private string CreateTypeMapBody(PersistentClassMapping[] mappings)
{
StringBuilder sb = new StringBuilder();
for (int m = 0; m < mappings.Length; ++m)
{
PersistentClassMapping mapping = mappings[m];
if (mapping == null)
{
continue;
}
if (!mapping.IsEnabled)
{
continue;
}
Type mappingType = Type.GetType(mapping.MappedAssemblyQualifiedName);
if (mappingType == null)
{
Debug.LogWarning("Type " + mapping.MappedAssemblyQualifiedName + " was not found");
continue;
}
string mappedTypeName = mappingType.Name;
if (mappedTypeName == "Object")
{
mappedTypeName = "UnityObject";
}
sb.AppendFormat(AddToPersistentTypeTemplate, mappedTypeName, mapping.PersistentTypeName);
sb.Append(TAB3);
sb.AppendFormat(AddToUnityTypeTemplate, mapping.PersistentTypeName, mappedTypeName);
sb.Append(TAB3);
sb.AppendFormat(AddToGuidTemplate, mapping.PersistentTypeName, mapping.PersistentTypeGUID);
sb.Append(TAB3);
sb.AppendFormat(AddToGuidTemplate, mappedTypeName, mapping.MappedTypeGUID);
sb.Append(TAB3);
sb.AppendFormat(AddToTypeTemplate, mapping.PersistentTypeGUID, mapping.PersistentTypeName);
sb.Append(TAB3);
sb.AppendFormat(AddToTypeTemplate, mapping.MappedTypeGUID, mappedTypeName);
sb.Append(TAB3);
}
sb.Append(BR);
return(sb.ToString());
}
private string CreateNamespaceDefinitions(PersistentClassMapping[] mappings)
{
StringBuilder sb = new StringBuilder();
HashSet <string> nsHs = new HashSet <string>();
for (int m = 0; m < mappings.Length; ++m)
{
PersistentClassMapping mapping = mappings[m];
if (!mapping.IsEnabled)
{
continue;
}
if (!nsHs.Contains(mapping.PersistentNamespace))
{
nsHs.Add(mapping.PersistentNamespace);
}
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping pMapping = mapping.PropertyMappings[i];
if (!pMapping.IsEnabled || pMapping.HasPropertyInTemplate)
{
continue;
}
if (!nsHs.Contains(pMapping.PersistentNamespace))
{
nsHs.Add(pMapping.PersistentNamespace);
}
}
}
foreach (string ns in nsHs)
{
sb.AppendFormat(NamespaceDefinitionTemplate, ns);
sb.Append(BR);
}
return(sb.ToString());
}
/// <summary>
/// Generate method which will extract and populate context with dependencies (referenced unity objects)
/// </summary>
/// <param name="mapping"></param>
/// <returns></returns>
private string CreateDepsFromMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled || prop.HasPropertyInTemplate)
{
continue;
}
if (prop.HasDependenciesOrIsDependencyItself)
{
string get = "uo.{0}";
if (prop.IsNonPublic)
{
get = "GetPrivate<" + prop.MappedTypeName + ">(uo, \"{0}\")";
}
if (prop.UseSurrogate)
{
sb.Append(TAB);
sb.AppendFormat("AddSurrogateDeps(" + get + ", v_ => ({1})v_, context);", prop.MappedName, "Persistent" + prop.PersistentTypeName);
sb.Append(BR + TAB2);
}
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) ||
prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)) ||
IsGenericList(prop.MappedType) && prop.MappedType.GetGenericArguments()[0].IsSubclassOf(typeof(UnityObject)))
{
sb.Append(TAB);
sb.AppendFormat("AddDep(" + get + ", context);", prop.MappedName);
sb.Append(BR + TAB2);
}
}
}
return(sb.ToString());
}
private string CreateTypeModelCreatorBody(PersistentClassMapping[] mappings)
{
StringBuilder sb = new StringBuilder();
for (int m = 0; m < mappings.Length; ++m)
{
PersistentClassMapping mapping = mappings[m];
if (mapping == null)
{
continue;
}
string endOfLine = string.Empty;
if (mapping.Subclasses != null && mapping.Subclasses.Length > 0)
{
endOfLine = CreateAddSubtypesBody(mapping);
}
Type mappingType = Type.GetType(mapping.MappedAssemblyQualifiedName);
if (mappingType == null)
{
Debug.LogWarning("Type " + mapping.MappedAssemblyQualifiedName + " was not found");
}
else
{
if (GetSurrogateType(mappingType) != null)
{
endOfLine += string.Format(SetSerializationSurrogate, PreparePersistentTypeName(mapping.PersistentTypeName));
}
}
endOfLine += SEMICOLON + BR + TAB3 + TAB;
sb.AppendFormat(AddTypeTemplate, PreparePersistentTypeName(mapping.PersistentTypeName), endOfLine);
}
return(sb.ToString());
}
private string CreateUsings(params PersistentClassMapping[] mappings)
{
StringBuilder sb = new StringBuilder();
HashSet <string> namespaces = new HashSet <string>();
for (int m = 0; m < mappings.Length; ++m)
{
PersistentClassMapping mapping = mappings[m];
if (mapping == null)
{
continue;
}
for (int i = 0; i < DefaultNamespaces.Length; ++i)
{
namespaces.Add(DefaultNamespaces[i]);
}
if (!namespaces.Contains(mapping.MappedNamespace))
{
namespaces.Add(mapping.MappedNamespace);
}
if (!namespaces.Contains(mapping.PersistentNamespace))
{
namespaces.Add(mapping.PersistentNamespace);
}
if (!namespaces.Contains(mapping.PersistentBaseNamespace))
{
namespaces.Add(mapping.PersistentBaseNamespace);
}
if (mapping.IsEnabled)
{
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping propertyMapping = mapping.PropertyMappings[i];
if (!propertyMapping.IsEnabled)
{
continue;
}
if (!namespaces.Contains(propertyMapping.MappedNamespace))
{
namespaces.Add(propertyMapping.MappedNamespace);
}
Type type = propertyMapping.MappedType;
Type replacementType = GetReplacementType(type);
if (replacementType != null)
{
if (!namespaces.Contains(replacementType.Namespace))
{
namespaces.Add(replacementType.Namespace);
}
}
else
{
if (!type.FullName.Contains("System"))
{
if (!namespaces.Contains(propertyMapping.PersistentNamespace))
{
namespaces.Add(propertyMapping.PersistentNamespace);
}
}
}
}
}
}
foreach (string ns in namespaces)
{
sb.Append("using " + ns + ";" + BR);
}
return(sb.ToString());
}
private string CreatePersistentClassBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled)
{
continue;
}
string typeName;
Type repacementType = GetReplacementType(prop.MappedType);
if (repacementType != null)
{
string primitiveTypeName;
if (m_primitiveNames.TryGetValue(repacementType, out primitiveTypeName))
{
typeName = primitiveTypeName;
}
else
{
typeName = PrepareMappedTypeName(repacementType.Name);
}
}
else
{
string primitiveTypeName;
if (m_primitiveNames.TryGetValue(prop.MappedType, out primitiveTypeName))
{
typeName = primitiveTypeName;
}
else
{
typeName = PreparePersistentTypeName(prop.PersistentTypeName);
}
}
sb.AppendFormat(
FieldTemplate, i + AutoFieldTagOffset,
typeName,
prop.PersistentName);
}
string readMethodBody = CreateReadMethodBody(mapping);
string writeMethodBody = CreateWriteMethodBody(mapping);
string getDepsMethodBody = CreateDepsMethodBody(mapping);
string getDepsFromMethodBody = CreateDepsFromMethodBody(mapping);
string mappedTypeName = PrepareMappedTypeName(mapping.MappedTypeName);
if (mappedTypeName == "Object")
{
mappedTypeName = "UnityObject";
}
if (!string.IsNullOrEmpty(readMethodBody))
{
sb.AppendFormat(ReadFromMethodTemplate, readMethodBody, mappedTypeName);
}
if (!string.IsNullOrEmpty(writeMethodBody))
{
sb.Append(BR + TAB2);
sb.AppendFormat(WriteToMethodTemplate, writeMethodBody, mappedTypeName);
}
if (!string.IsNullOrEmpty(getDepsMethodBody))
{
sb.Append(BR + TAB2);
sb.AppendFormat(GetDepsMethodTemplate, getDepsMethodBody);
}
if (!string.IsNullOrEmpty(getDepsFromMethodBody))
{
sb.Append(BR + TAB2);
sb.AppendFormat(GetDepsFromMethodTemplate, getDepsFromMethodBody, mappedTypeName);
}
Type mappingType = Type.GetType(mapping.MappedAssemblyQualifiedName);
if (mappingType.GetConstructor(Type.EmptyTypes) != null || mappingType.IsValueType)
{
sb.Append(BR + TAB2);
sb.AppendFormat(ImplicitOperatorsTemplate, mappedTypeName, PreparePersistentTypeName(mapping.PersistentTypeName));
}
return(sb.ToString());
}
private string CreateWriteMethodBody(PersistentClassMapping mapping)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mapping.PropertyMappings.Length; ++i)
{
PersistentPropertyMapping prop = mapping.PropertyMappings[i];
if (!prop.IsEnabled || prop.HasPropertyInTemplate)
{
continue;
}
sb.Append(TAB);
string get = "uo.{0}";
if (prop.IsNonPublic)
{
get = "GetPrivate<" + prop.MappedTypeName + ">(uo, \"{0}\")";
}
if (prop.MappedType.IsSubclassOf(typeof(UnityObject)) ||
prop.MappedType.IsArray && prop.MappedType.GetElementType().IsSubclassOf(typeof(UnityObject)) ||
IsGenericList(prop.MappedType) && prop.MappedType.GetGenericArguments()[0].IsSubclassOf(typeof(UnityObject)))
{
//generate code which will convert identifier to unity object
//Type mappedType = prop.MappedType.IsArray ? prop.MappedType.GetElementType() : prop.MappedType;
//sb.AppendFormat("uo.{0} = FromID<{2}>({1}, uo.{0});", prop.MappedName, prop.PersistentName, PrepareMappedTypeName(mappedType.Name));
if (prop.IsNonPublic)
{
sb.AppendFormat("SetPrivate(uo, \"{0}\", FromID({1}, " + get + "));", prop.MappedName, prop.PersistentName);
}
else
{
sb.AppendFormat("uo.{0} = FromID({1}, " + get + ");", prop.MappedName, prop.PersistentName);
}
}
else
{
if (prop.UseSurrogate)
{
if (IsGenericList(prop.MappedType))
{
if (prop.IsNonPublic)
{
sb.AppendFormat("SetPrivate(uo, \"{0}\", Assign({1}, v_ => ({2})v_));", prop.MappedName, prop.PersistentName, prop.MappedType.GetGenericArguments()[0].Name);
}
else
{
sb.AppendFormat("uo.{0} = Assign({1}, v_ => ({2})v_);", prop.MappedName, prop.PersistentName, prop.MappedType.GetGenericArguments()[0].Name);
}
}
else if (prop.MappedType.IsArray)
{
if (prop.IsNonPublic)
{
sb.AppendFormat("SetPrivate(uo, \"{0}\", Assign({1}, v_ => ({2})v_));", prop.MappedName, prop.PersistentName, prop.MappedType.GetElementType().Name);
}
else
{
sb.AppendFormat("uo.{0} = Assign({1}, v_ => ({2})v_);", prop.MappedName, prop.PersistentName, prop.MappedType.GetElementType().Name);
}
}
else
{
if (prop.IsNonPublic)
{
sb.AppendFormat("SetPrivate(uo, \"{0}\", {1});", prop.MappedName, prop.PersistentName);
}
else
{
sb.AppendFormat("uo.{0} = {1};", prop.MappedName, prop.PersistentName);
}
}
}
else
{
if (prop.IsNonPublic)
{
sb.AppendFormat("SetPrivate(uo, \"{0}\", {1});", prop.MappedName, prop.PersistentName);
}
else
{
sb.AppendFormat("uo.{0} = {1};", prop.MappedName, prop.PersistentName);
}
}
}
sb.Append(BR + TAB2);
}
return(sb.ToString());
}