public RefsKeyItem(StorageKeyEntry keyEntry, EditableRefValue[] refs) : base(keyEntry.StorageKey)
{
RefItems = new RefItem[refs.Length];
for (int i = 0; i < refs.Length; i++)
{
RefItems[i] = new RefItem(keyEntry, refs[i]);
}
}
public ValItem(StorageKeyEntry keyEntry, SaveableValueSection valueSection) : base(keyEntry.StorageKey)
{
_keyEntry = keyEntry;
_valueSection = valueSection;
if (_valueSection.GetSafeValueType() == typeof(SaveableDict))
{
_dictValue = (SaveableDict)_valueSection.GetValue();
}
else if (_valueSection.GetSafeValueType() == typeof(SaveableArray))
{
_arrayValue = (SaveableArray)_valueSection.GetValue();
}
}
public static Dictionary <string, StorageKeyEntry> GetKeyEntries(Type saveableType)
{
if (saveableType == null)
{
return(new Dictionary <string, StorageKeyEntry>());
}
FieldInfo[] fields = saveableType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
Dictionary <string, StorageKeyEntry> keyEntries = new Dictionary <string, StorageKeyEntry>();
// Add keys of the saveable itself
foreach (FieldInfo fInfo in fields)
{
StorageKeyAttribute keyAttribute = fInfo.GetCustomAttribute <StorageKeyAttribute>(true);
if (keyAttribute != null)
{
StorageKeyEntry entry = new StorageKeyEntry(fInfo.GetValue(null) as string, keyAttribute.ExpectedType, keyAttribute.IsOptional);
AddKeyEntry(keyEntries, entry);
}
}
// Add keys of StorageKeysHolders (holding keys for other types)
StorageKeysHolderAttribute ska = saveableType.GetCustomAttribute <StorageKeysHolderAttribute>(false);
if (ska == null || !ska.ContainerForType.IsAssignableFrom(saveableType))
{
Type[] storageKeysHolders = Assembly.GetAssembly(typeof(StorageKeysHolderAttribute)).GetTypes().Where(x =>
{
StorageKeysHolderAttribute attr = x.GetCustomAttribute <StorageKeysHolderAttribute>(false);
return(attr != null && attr.ContainerForType.IsAssignableFrom(saveableType));
}).ToArray();
for (int i = 0; i < storageKeysHolders.Length; i++)
{
Dictionary <string, StorageKeyEntry> storageKeysHolderEntries = GetKeyEntries(storageKeysHolders[i]);
foreach (var newKeyEntryPair in storageKeysHolderEntries)
{
AddKeyEntry(keyEntries, newKeyEntryPair.Value);
}
}
}
return(keyEntries);
}
public StorageItem(string parentKey, IStorageDictionaryEditor storageDictionaryEditor, Dictionary <string, StorageKeyEntry> keyEntries)
: base(parentKey, string.Concat("Storage: (", parentKey, ")"), false)
{
KeyEntries = keyEntries;
if (storageDictionaryEditor != null)
{
string[] valKeys = storageDictionaryEditor.GetValueStorageKeys();
ValKeys = new ValKeyItem[valKeys.Length];
for (int i = 0; i < valKeys.Length; i++)
{
if (!keyEntries.TryGetValue(valKeys[i], out StorageKeyEntry valueEntry))
{
valueEntry = new StorageKeyEntry()
{
StorageKey = valKeys[i],
};
}
ValKeys[i] = new ValKeyItem(valueEntry, storageDictionaryEditor.GetValueSection(valKeys[i]));
}
string[] refKeys = storageDictionaryEditor.GetRefStorageKeys();
RefsKeys = new RefsKeyItem[refKeys.Length];
for (int i = 0; i < refKeys.Length; i++)
{
if (!keyEntries.TryGetValue(refKeys[i], out StorageKeyEntry refEntry))
{
refEntry = new StorageKeyEntry()
{
StorageKey = refKeys[i],
};
}
RefsKeys[i] = new RefsKeyItem(refEntry, storageDictionaryEditor.GetValueRefs(refKeys[i]));
}
}
else
{
ValKeys = new ValKeyItem[] { };
RefsKeys = new RefsKeyItem[] { };
}
}
private StorageKeyEntry[] GetMissingKeyEntries()
{
List <StorageKeyEntry> missingEntries = new List <StorageKeyEntry>(KeyEntries.Select(x => x.Value).Where(x => !x.IsOptional));
for (int i = 0; i < ValKeys.Length; i++)
{
StorageKeyEntry entry = missingEntries.Find(x => x.StorageKey == ValKeys[i].Key);
if (entry.IsValid)
{
missingEntries.Remove(entry);
}
}
for (int i = 0; i < RefsKeys.Length; i++)
{
StorageKeyEntry entry = missingEntries.Find(x => x.StorageKey == RefsKeys[i].Key);
if (entry.IsValid)
{
missingEntries.Remove(entry);
}
}
return(missingEntries.ToArray());
}
public ValKeyItem(StorageKeyEntry keyEntry, SaveableValueSection value) : base(keyEntry.StorageKey)
{
ValItem = new ValItem(keyEntry, value);
}
public RefItem(StorageKeyEntry keyEntry, EditableRefValue editableRefValue) : base(keyEntry.StorageKey)
{
_keyEntry = keyEntry;
_editableRefValue = editableRefValue;
StorageItem = new StorageItem(keyEntry.StorageKey, _editableRefValue.Storage, GetKeyEntries(_editableRefValue.ReferenceType));
}
private static void AddKeyEntry(Dictionary <string, StorageKeyEntry> entries, StorageKeyEntry entry)
{
if (!entries.ContainsKey(entry.StorageKey))
{
entries.Add(entry.StorageKey, entry);
}
else
{
entry.HasDuplicate = true;
entries[entry.StorageKey] = entry;
}
}
