/// <summary> /// 回收引用对象 /// </summary> public void Release(IReference item) { if (item == null) return; if (item.GetType() != ClassType) throw new Exception($"Invalid type {item.GetType()}"); if (_pool.Contains(item)) throw new Exception($"The item {item.GetType()} already exists."); SpawnCount--; item.OnRelease(); _pool.Enqueue(item); }
public void OnDeSpawn(IReference re) { Type t = re.GetType(); ReferencePool referencePool = mReferencePools[t]; referencePool.OnDeSpawn(re); }
/// <summary> /// 将引用归还引用池。 /// </summary> /// <param name="referenceType">引用类型。</param> /// <param name="reference">引用。</param> public static void Release(Type referenceType, IReference reference) { if (referenceType == null) { throw new GameFrameworkException("Reference type is invalid."); } if (!referenceType.IsClass || referenceType.IsAbstract) { throw new GameFrameworkException("Reference type is not a non-abstract class type."); } if (reference == null) { throw new GameFrameworkException("Reference is invalid."); } Type type = reference.GetType(); if (referenceType != type) { throw new GameFrameworkException(string.Format("Reference type '{0}' not equals to reference's type '{1}'.", referenceType.FullName, type.FullName)); } reference.Clear(); lock (s_ReferencePool) { GetReferencePool(referenceType.FullName).Enqueue(reference); } }
public static void Release(Type referenceType, IReference reference) { if (referenceType == null) { } if (!referenceType.IsClass || referenceType.IsAbstract) { } if (reference == null) { } Type type = reference.GetType(); if (referenceType != type) { throw; } reference.Clear(); lock (s_ReferencePool) { GetReferencePool(referenceType.FullName).Enqueue(reference); } }
private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference) { var error = reference.CheckResolveResult(); if (error == null) { throw new InvalidOperationException("ResolveErrorType is null for reference " + reference.GetType().FullName); } if (error == ResolveErrorType.OK) { return; } if (myResolveHighlighterRegistrar.ContainsHandler(ShaderLabLanguage.Instance, error)) { var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, error); if (highlighting != null) { consumer.AddHighlighting(highlighting); } } else { consumer.AddHighlighting(new NotResolvedError(reference)); } }
/// <summary> /// 回收引用 /// </summary> /// <param name="refe">对象</param> public void Despawn(IReference refe) { Type type = refe.GetType(); if (!_spawnPools.ContainsKey(type)) { _spawnPools.Add(type, new ReferenceSpawnPool(Limit)); } _spawnPools[type].Despawn(refe); }
public void Despawn(IReference refer) { Type type = refer.GetType(); if (!referenceDict.ContainsKey(type)) { referenceDict.TryAdd(type, new ReferenceSpawnPool()); } referenceDict[type].Despawn(refer); }
/// <summary> /// 回收引用对象 /// </summary> public static void Release(IReference item) { Type type = item.GetType(); if (_pools.ContainsKey(type) == false) { _pools.Add(type, new ReferencePool(type, InitCapacity)); } _pools[type].Release(item); }
/// <summary> /// 回收引用对象 /// </summary> public static void Release(IReference item) { Type type = item.GetType(); if (_collectors.ContainsKey(type) == false) { _collectors.Add(type, new ReferenceCollector(type, InitCapacity)); } _collectors[type].Release(item); }
/// <summary> /// 将引用归还引用池 /// </summary> /// <param name="reference">引用</param> public static void Release(IReference reference) { if (reference == null) { throw new Exception("[ReferencePool.Release] Reference is invalid -> reference == null"); } Type referenceType = reference.GetType(); InternalCheckReferenceType(referenceType); GetReferenceCollection(referenceType).Release(reference); }
/// <summary> /// 将引用归还引用池。 /// </summary> /// <param name="reference">引用。</param> public static void Release(IReference reference) { if (reference == null) { Log.Error("Reference is invalid."); } Type referenceType = reference.GetType(); InternalCheckReferenceType(referenceType); GetReferenceCollection(referenceType).Release(reference); }
/// <summary> /// 将引用归还引用池。 /// </summary> /// <typeparam name="T">引用类型。</typeparam> /// <param name="reference">引用。</param> public static void Recycle(IReference reference) { if (reference == null) { Logger.LogError("Reference is invalid."); } lock (s_ReferencePool) { GetReferencePool(reference.GetType()).Enqueue(reference); } }
/// <summary> /// 回收引用对象 /// </summary> public void Release(IReference item) { if (item == null) { return; } if (item.GetType() != ClassType) { throw new Exception($"Invalid type {item.GetType()}"); } if (_collector.Contains(item)) { throw new Exception($"The item {item.GetType()} already exists."); } SpawnCount--; item.OnRelease(); _collector.Enqueue(item); }
/// <summary> /// 将引用归还引用池。 /// </summary> /// <param name="reference">引用。</param> public static void Release(IReference reference) { if (reference == null) { throw new GameFrameworkException("Reference is invalid."); } Type referenceType = reference.GetType(); InternalCheckReferenceType(referenceType); GetReferenceCollection(referenceType).Release(reference); }
/// <summary> /// 回收引用 /// </summary> /// <param name="refe">对象</param> public void Despawn(IReference refe) { if (refe == null) { return; } Type type = refe.GetType(); if (!SpawnPools.ContainsKey(type)) { SpawnPools.Add(type, new ReferenceSpawnPool(_limit)); } SpawnPools[type].Despawn(refe); }
/// <summary> /// 将引用归还引用池。 /// </summary> /// <param name="referenceType">引用类型。</param> /// <param name="reference">引用。</param> public static void Release(Type referenceType, IReference reference) { InternalCheckReferenceType(referenceType); if (reference == null) { throw new GameFrameworkException("Reference is invalid."); } Type type = reference.GetType(); if (referenceType != type) { throw new GameFrameworkException(string.Format("Reference type '{0}' not equals to reference's type '{1}'.", referenceType.FullName, type.FullName)); } GetReferenceCollection(referenceType.FullName).Release(reference); }
public static string GetIDStringForReference(IReference reference) { if (reference is ITypeReference) { return(TypeHelper.GetTypeName((ITypeReference)reference, NameFormattingOptions.DocumentationId)); } else if (reference is IMethodReference) { return(MemberHelper.GetMethodSignature((IMethodReference)reference, NameFormattingOptions.DocumentationId)); } else if (reference is IFieldDefinition) { return(MemberHelper.GetMemberSignature((IFieldReference)reference, NameFormattingOptions.DocumentationId)); } else { throw new ArgumentException("Un-supported reference type: " + reference.GetType()); } }
private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference) { var error = reference.CheckResolveResult(); if (error == null) { throw new InvalidOperationException("ResolveErrorType is null for reference " + reference.GetType().FullName); } if (error == ResolveErrorType.OK) { return; } // ReSharper disable once AssignNullToNotNullAttribute if (myResolveHighlighterRegistrar.ContainsHandler(ShaderLabLanguage.Instance, error)) { var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, error); if (highlighting != null) { consumer.AddHighlighting(highlighting); } } else { // The default is unresolved. But we can't use something like NotResolvedError because: // a) Using an undeclared property in ShaderLab isn't a compile time error. An undeclared // property just uses the default value // b) Properties can be set from code, without having to be declared first // c) There is at least one hidden property `unity_GUIZTestMode` // // So, this could be: // a) a typo // b) an external reference // // How do we tell the difference, and how do we show the difference? // For now, just don't give an error consumer.AddHighlighting(new NotResolvedPropertyWarning(reference)); } }
public virtual void VisitNode(IReference node) { IAssembly assembly = node as IAssembly; INamedTypeDefinition type = node as INamedTypeDefinition; ITypeDefinitionMember member = node as ITypeDefinitionMember; IAliasForType alias = node as IAliasForType; if (assembly != null) { if (m_implModel.CanIncludeAssembly(assembly.AssemblyIdentity)) { Visit(assembly); } } else if (type != null) { INamedTypeReference typeRef = Util.CanonicalizeTypeReference(type); if (m_implModel.CanInclude(typeRef)) { Visit(type); } } else if (member != null) { INamedTypeReference typeRef = Util.CanonicalizeTypeReference(member.ContainingType); if (m_implModel.CanInclude(typeRef)) { Visit(member); } } else if (alias != null) { Visit(alias); } else { throw new Exception("Illegal node: " + node.GetType().Name); } }
private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference) { var resolveErrorType = reference.CheckResolveResult(); if (resolveErrorType == null) { throw new InvalidOperationException("ResolveErrorType is null for reference " + reference.GetType().FullName); } if (resolveErrorType.IsAcceptable) { return; } // ReSharper disable once AssignNullToNotNullAttribute if (myResolveHighlighterRegistrar.ContainsHandler(YamlLanguage.Instance, resolveErrorType)) { var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, resolveErrorType); if (highlighting != null) { consumer.AddHighlighting(highlighting); } } else { consumer.AddHighlighting(new NotResolvedError(reference)); } }
public static IAssemblyReference GetAssemblyReference(this IReference reference) { Contract.Requires(reference != null); Contract.Requires(!(reference is Dummy)); IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly); } ITypeReference type = reference as ITypeReference; if (type != null) { return(type.GetAssemblyReference()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.ContainingType.GetAssemblyReference()); } throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, LocalizedStrings.UnknownIReference, reference.GetType().FullName)); }
public static string FullName(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(TypeHelper.GetTypeName(type, NameFormattingOptions.TypeParameters)); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(MemberHelper.GetMemberSignature(member, NameFormattingOptions.TypeParameters | NameFormattingOptions.Signature)); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(TypeHelper.GetNamespaceName(ns, NameFormattingOptions.None)); } INamedEntity named = reference as INamedEntity; if (named != null) { return(named.Name.Value); } Contract.Assert(false, String.Format(CultureInfo.CurrentCulture, LocalizedStrings.FellThroughCasesIn, "TypeExtensions.FullName()", reference.GetType())); return(LocalizedStrings.UnknownReferenceType); }
public static string RefDocId(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(type.DocId()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.DocId()); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(ns.DocId()); } IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly.DocId()); } Contract.Assert(false, string.Format("Fell through cases in TypeExtensions.RefDocId() Type of reference: {0}", reference.GetType())); return("<Unknown Reference Type>"); }
public static string RefDocId(this IReference reference) { Contract.Requires(reference != null); if (reference is ITypeReference type) { return(type.DocId()); } else if (reference is ITypeMemberReference member) { return(member.DocId()); } else if (reference is IUnitNamespaceReference ns) { return(ns.DocId()); } else if (reference is IAssemblyReference assembly) { return(assembly.DocId()); } Contract.Assert(false, string.Format(CultureInfo.CurrentUICulture, LocalizedStrings.FellThroughCasesIn, "DocIdExtensions.RefDocId()", reference.GetType())); return(LocalizedStrings.UnknownReferenceType); }
public static string FullName(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(TypeHelper.GetTypeName(type, NameFormattingOptions.TypeParameters)); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(MemberHelper.GetMemberSignature(member, NameFormattingOptions.TypeParameters | NameFormattingOptions.Signature)); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(TypeHelper.GetNamespaceName(ns, NameFormattingOptions.None)); } INamedEntity named = reference as INamedEntity; if (named != null) { return(named.Name.Value); } Contract.Assert(false, String.Format("Fell through cases in TypeExtensions.FullName() Type of reference: {0}", reference.GetType())); return("<Unknown Reference Type>"); }
public static IAssemblyReference GetAssemblyReference(this IReference reference) { Contract.Requires(reference != null); Contract.Requires(!(reference is Dummy)); IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly); } ITypeReference type = reference as ITypeReference; if (type != null) { return(type.GetAssemblyReference()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.ContainingType.GetAssemblyReference()); } throw new NotSupportedException(string.Format("Unknown IReference '{0}' so we cannot get assembly reference!", reference.GetType().FullName)); }