protected string GetStorageTypeName(Type rootType, AssetDeclarationAttributeBase attribute)
{
var groupName = CodeGenerationUtility.GetGroupName(attribute.Group);
var typeName = GetShortTypeName(GetTypeName(rootType, false));
return($"{groupName}{typeName}Storage");
}
private static DataRoute CreateRoute(RootDefinition d,
AssetDeclarationAttributeBase a,
List <SourceBase> sources,
List <Storage> storages)
{
return(CreateRoute(d, a, sources, storages, new List <string>()));
}
private static DataRoute CreateRoute(RootDefinition d,
AssetDeclarationAttributeBase a,
List <SourceBase> sources,
List <Storage> storages)
{
var route = new DataRoute
{
Root = d,
Attribute = a,
Sources = sources.FindAll(s => s.Contains(a.Group)),
Storages = storages.FindAll(s => s.Includes(a.Group)),
};
if (route.Attribute.IsSingle())
{
var storage = route.Sources.Where(s1 => s1.IsSingle)
.Cast <SingleSource>()
.FirstOrDefault(s => s != null && s.GetAsset(route.Group) != null);
var asset = storage != null?storage.GetAsset(route.Group) : null;
if (asset != null)
{
route.FileAssetPaths.Add(asset.GetAssetPath());
}
}
else
{
foreach (var source in route.Sources)
{
if (source.IsSingle)
{
var asset = source.GetSingleAsset(route.Group);
if (asset != null)
{
route.FileAssetPaths.Add(asset.GetAssetPath());
}
}
else
{
var isRecursive = (source as FolderSource)?.IsRecursive ?? false;
var paths = isRecursive ? route.RootAssetPaths : route.FolderAssetPaths;
paths.Add(source.GetAssetPathFolder());
}
}
route.FileAssetPaths.AddRange(route.Sources.SelectMany(s => s.GetAssets(route.Attribute)).Select(textAsset => textAsset.GetAssetPath()));
}
foreach (var storage in route.Storages)
{
route.FileAssetPaths.Add(storage.GetAssetPath());
}
foreach (var source in route.Sources)
{
route.FileAssetPaths.Add(source.GetAssetPath());
}
return(route);
}
internal static IEnumerable <TextAsset> GetAssets(this SourceBase source, AssetDeclarationAttributeBase attribute)
{
if (attribute.GetDeclarationType() == DeclarationType.Single ||
attribute.GetIsSingleFile())
{
if (!source.IsSingle)
{
yield break;
}
var singleSource = source as SingleSource;
if (singleSource == null)
{
yield break;
}
var asset = singleSource.GetAsset(attribute.Group);
if (asset != null)
{
yield return(asset);
}
}
else
{
var singleSource = source as SingleSource;
if (singleSource != null)
{
var asset = singleSource.GetAsset(attribute.Group);
if (asset != null)
{
yield return(asset);
}
}
else
{
var folderPath = GetAssetPathFolder(source.GetAssetPath());
var assetPaths = AssetDatabase.FindAssets($"t:{nameof(TextAsset)}", new[] { folderPath })
.Select(AssetDatabase.GUIDToAssetPath)
.Where(IsSupportedTextAssetPath)
.ToArray();
var multiSource = source as FolderSource;
if (multiSource == null)
{
yield break;
}
foreach (var assetPath in assetPaths)
{
if (multiSource.IsRecursive ||
GetAssetPathFolder(assetPath) == folderPath)
{
yield return(AssetDatabase.LoadAssetAtPath <TextAsset>(assetPath));
}
}
}
}
}
public void StorageType(RootDefinition root, AssetDeclarationAttributeBase attribute)
{
var storageTypeName = GetStorageTypeName(root.Root, attribute);
var rootTypeName = GetTypeName(root.Root, false);
var typeGuid = Guid.NewGuid().ToString();
var attributeGroup = attribute.Group;
const string format = @"
[Storage(""<#=attributeGroup#>"", typeof(<#=rootTypeName#>))]
[GuidAttribute(""<#=typeGuid#>"")]
public sealed class <#=storageTypeName#>
: StorageBase
{
public <#=storageTypeName#>()
{
Group = ""<#=attributeGroup#>"";
}
protected override object GetStoredValue()
{
return Value;
}
";
_stringBuilder
.AppendLine()
.Append(new StringBuilder(format)
.Replace("<#=attributeGroup#>", attributeGroup)
.Replace("<#=rootTypeName#>", rootTypeName)
.Replace("<#=storageTypeName#>", storageTypeName)
.Replace("<#=typeGuid#>", typeGuid))
.AppendLine();
if (attribute is SingleAssetAttribute)
{
SingleStorageTypeContent(root, storageTypeName);
}
else if (attribute is AssetListAttribute)
{
ListStorageTypeContent(root, storageTypeName);
}
else if (attribute is AssetDictionaryAttribute)
{
DictionaryStorageTypeContent(root, storageTypeName, attribute as AssetDictionaryAttribute);
}
_stringBuilder.AppendLine(" }");
}
public static NamingConvention GetNamingConvention(this AssetDeclarationAttributeBase attribute)
{
return(attribute.ExplicitNamingConvention ?? YamlySettings.Instance.NamingConvention);
}
private static DataRoute CreateRoute(RootDefinition d,
AssetDeclarationAttributeBase a,
YamlyProjectContext c)
{
return(CreateRoute(d, a, c.Sources, c.Storages));
}
private static DataRoute CreateRoute(RootDefinition d,
AssetDeclarationAttributeBase a)
{
return(CreateRoute(d, a, Context.Sources, Context.Storages));
}
