internal DependencyManager(IResourceFinder resourceFinder, IDependencyCache dependencyCache, IResourceGroupManager scriptGroups, IResourceGroupManager styleGroups)
{
_resourceFinder = resourceFinder;
_dependencyCache = dependencyCache;
_scriptGroups = scriptGroups;
_styleGroups = styleGroups;
}
internal DependencyManager(IResourceFinder resourceFinder, IDependencyCache dependencyCache, IResourceGroupManager scriptGroups, IResourceGroupManager styleGroups, ResourceMode resourceMode)
{
_resourceFinder = resourceFinder;
_dependencyCache = dependencyCache;
_scriptGroups = scriptGroups;
_styleGroups = styleGroups;
_resourceMode = resourceMode;
}
public static void ClearCacheFiles()
{
List <Type> types = GetTypesForBaseType(typeof(IDependencyCache));
foreach (Type type in types)
{
IDependencyCache cache = InstantiateClass <IDependencyCache>(type);
cache.ClearFile(DEFAULT_CACHE_SAVE_PATH);
}
}
public static Dictionary <string, Node> CreateRelationMapping(List <CreatedDependencyCache> dependencyCaches)
{
List <IResolvedNode> resolvedNodes = new List <IResolvedNode>();
Dictionary <string, List <IDependencyCache> > typeToCaches = new Dictionary <string, List <IDependencyCache> >();
Dictionary <string, Node> nodeDictionary = new Dictionary <string, Node>();
foreach (CreatedDependencyCache dependencyCache in dependencyCaches)
{
IDependencyCache cache = dependencyCache.Cache;
string handledNodeType = cache.GetHandledNodeType();
if (!typeToCaches.ContainsKey(handledNodeType))
{
typeToCaches.Add(handledNodeType, new List <IDependencyCache>());
}
typeToCaches[handledNodeType].Add(cache);
cache.AddExistingNodes(resolvedNodes);
cache.InitLookup();
}
// create dependency structure here
foreach (var resolvedNode in resolvedNodes)
{
Node referencerNode = GetOrCreateNode(resolvedNode.Id, resolvedNode.Type, nodeDictionary);
foreach (IDependencyCache dependencyCache in typeToCaches[referencerNode.Type])
{
List <Dependency> dependenciesForId = dependencyCache.GetDependenciesForId(referencerNode.Id);
foreach (Dependency dependency in dependenciesForId)
{
Node dependencyNode = GetOrCreateNode(dependency.Id, dependency.NodeType, nodeDictionary);
referencerNode.Dependencies.Add(
new Connection(dependencyNode, dependency.ConnectionType, dependency.PathSegments));
}
}
}
// create reference structure here
foreach (var pair in nodeDictionary)
{
Node referencerNode = pair.Value;
foreach (Connection connection in referencerNode.Dependencies)
{
connection.Node.Referencers.Add(new Connection(referencerNode, connection.Type, connection.PathSegments));
}
}
EditorUtility.ClearProgressBar();
return(nodeDictionary);
}
private void AddDefaultCacheActivation(IDependencyCache cache, IDependencyResolver resolver)
{
CacheState cacheState = new CacheState(cache);
ResolverState resolverState = new ResolverState(resolver);
cacheState.ResolverStates.Add(resolverState);
cacheState.IsActive = true;
resolverState.IsActive = true;
resolverState.ActiveConnectionTypes = new HashSet <string>(resolver.GetConnectionTypes());
cacheState.SaveState();
}
public static void LoadDependencyLookupForCaches(NodeDependencyLookupContext stateContext,
ResolverUsageDefinitionList resolverUsageDefinitionList, ProgressBase progress, bool loadCache = true,
bool updateCache = true, bool saveCache = true, string fileDirectory = DEFAULT_CACHE_SAVE_PATH)
{
stateContext.UpdateFromDefinition(resolverUsageDefinitionList);
List <CreatedDependencyCache> caches = stateContext.GetCaches();
foreach (CreatedDependencyCache cacheUsage in caches)
{
if (cacheUsage.ResolverUsages.Count == 0)
{
continue;
}
IDependencyCache cache = cacheUsage.Cache;
if (loadCache && !cacheUsage.IsLoaded)
{
cache.Load(fileDirectory);
cacheUsage.IsLoaded = true;
}
if (updateCache && cache.NeedsUpdate(progress))
{
if (cache.CanUpdate())
{
cache.Update(progress);
if (saveCache)
{
cache.Save(fileDirectory);
}
}
else
{
Debug.LogErrorFormat("{0} could not be updated", cache.GetType().FullName);
}
}
}
RelationLookup.RelationsLookup lookup = new RelationLookup.RelationsLookup();
lookup.Build(caches);
stateContext.RelationsLookup = lookup;
}
public void UpdateFromDefinition(ResolverUsageDefinitionList definitionList)
{
ResetCacheUsages();
foreach (ResolverUsageDefinitionList.Entry entry in definitionList.CacheUsages)
{
string cacheTypeFullName = entry.CacheType.FullName;
if (!CreatedCaches.ContainsKey(cacheTypeFullName))
{
IDependencyCache cache = NodeDependencyLookupUtility.InstantiateClass <IDependencyCache>(entry.CacheType);
CreatedDependencyCache createdCache = new CreatedDependencyCache(cache);
CreatedCaches.Add(cacheTypeFullName, createdCache);
}
CreatedCaches[cacheTypeFullName].AddResolver(entry.ResolverType, entry.ConnectionTypes);
}
ConnectionTypeLookup = new ConnectionTypeLookup(GetCaches());
NodeHandlerLookup = NodeDependencyLookupUtility.BuildNodeHandlerLookup();
}
private void CreateCacheStates()
{
_cacheStates.Clear();
List <Type> types = NodeDependencyLookupUtility.GetTypesForBaseType(typeof(IDependencyCache));
foreach (Type type in types)
{
IDependencyCache cache = NodeDependencyLookupUtility.InstantiateClass <IDependencyCache>(type);
var cacheState = new CacheState(cache);
List <Type> resolverTypes = NodeDependencyLookupUtility.GetTypesForBaseType(cache.GetResolverType());
foreach (Type rtype in resolverTypes)
{
IDependencyResolver dependencyResolver = NodeDependencyLookupUtility.InstantiateClass <IDependencyResolver>(rtype);
cacheState.ResolverStates.Add(new ResolverState(dependencyResolver));
}
_cacheStates.Add(cacheState);
}
}
private AllWishSets(IDependencyCache cache, AllWishSets parent, int depth)
{
m_depth = depth;
m_cache = cache;
m_wishSetsByKey = new Dictionary<Key, ResolverWishSet>(parent.m_wishSetsByKey);
}
public AllWishSets(IDependencyCache cache)
{
m_depth = 0;
m_cache = cache;
m_wishSetsByKey = new Dictionary<Key, ResolverWishSet>();
}
public void SetCache(IDependencyCache cache)
{
_dependencyCache = cache;
}
public CacheState(IDependencyCache cache)
{
Cache = cache;
IsActive = EditorPrefs.GetBool(GetPrefKey());
}
public static ProjectDependencyResolver WithCache(IDependencyCache cache)
{
return new ProjectDependencyResolver(cache);
}
private ProjectDependencyResolver(IDependencyCache cache)
{
DepsCache = cache;
}
public void SetCache(IDependencyCache cache)
{
_dependencyCache = cache;
}
private ResolverLine(IDependencyCache cache, AllWishSets wishSets, int depth)
{
m_cache = cache;
m_depth = depth;
m_wishSets = wishSets;
}
internal ResolverLine(IDependencyCache cache)
: this(cache, new AllWishSets(cache), 0)
{
}
internal WishDependencyResolver(IDependencyCache cache)
{
m_cache = cache;
}
public CreatedDependencyCache(IDependencyCache cache)
{
Cache = cache;
cache.Initialize(this);
}
public static WishDependencyResolver WithCache(IDependencyCache cache)
{
return new WishDependencyResolver(cache);
}
