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; }
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); }