private string ResolveTypeToLabel0(MissingType type) { if (type == MissingType.Undefined) { return(" "); } return(" " + type.ToString().Translate() + " "); }
private string ResolveTypeToLabel1(MissingType type) { if (type == MissingType.Undefined) { return(" " + "FCPawns".Translate() + " "); } return(ResolveTypeToLabel0(type)); }
public void Method(MissingType argument) // Error [CS0246] { var str = "xxx"; throw new ArgumentNullException(nameof(argument)); // Noncompliant {{The parameter name '' is not declared in the argument list.}} FP with wrong message throw new ArgumentNullException(nameof(argument.argument)); // Compliant throw new ArgumentNullException(nameof(str.argument)); // Error [CS1061] Compliant, argument is missing member without a symbol }
/// <summary> /// Determines whether the specified service type is registered. /// </summary> /// <param name="serviceType">The type of the service.</param> /// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param> /// <returns><c>true</c> if the specified service type is registered; otherwise, <c>false</c>.</returns> /// <remarks>Note that the actual implementation lays in the hands of the IoC technique being used.</remarks> /// <exception cref="ArgumentNullException">The <paramref name="serviceType"/> is <c>null</c>.</exception> public bool IsTypeRegistered(Type serviceType, object tag = null) { Argument.IsNotNull("serviceType", serviceType); var serviceInfo = new ServiceInfo(serviceType, tag); lock (_syncObject) { if (_registeredInstances.ContainsKey(serviceInfo)) { return(true); } if (_registeredTypes.ContainsKey(serviceInfo)) { return(true); } foreach (var externalContainerKeyValuePair in _externalContainers) { var registrationInfo = externalContainerKeyValuePair.Value.GetRegistrationInfo(externalContainerKeyValuePair.Key, serviceType); if (registrationInfo != null) { // Now we know the container, register it as typeof(object), we will re-register as soon as the actual type is known _registeredTypes[serviceInfo] = new RegisteredTypeInfo(serviceType, typeof(object), tag, registrationInfo.RegistrationType, externalContainerKeyValuePair.Value); return(true); } } // Last resort var eventArgs = new MissingTypeEventArgs(serviceType); MissingType.SafeInvoke(this, eventArgs); if (eventArgs.ImplementingInstance != null) { Log.Debug("Late registering type '{0}' to instance of type '{1}' via MissingTypeEventArgs.ImplementingInstance", serviceType.FullName, eventArgs.ImplementingInstance.GetType().FullName); RegisterInstance(serviceType, eventArgs.ImplementingInstance, eventArgs.Tag, this); return(true); } if (eventArgs.ImplementingType != null) { Log.Debug("Late registering type '{0}' to type '{1}' via MissingTypeEventArgs.ImplementingType", serviceType.FullName, eventArgs.ImplementingType.FullName); RegisterType(serviceType, eventArgs.ImplementingType, eventArgs.Tag, eventArgs.RegistrationType, true, this); return(true); } } return(false); }
private static void FindInSelected(MissingType missing) { GameObject[] gos = Selection.gameObjects; _goCnt = 0; _componentsCnt = 0; _missingCnt = 0; foreach (GameObject go in gos) { FindInGO(go, missing); } Debug.Log(string.Format("Searched for missing " + missing + " {0} GameObjects, {1} components, found {2} missing", _goCnt, _componentsCnt, _missingCnt)); }
/// <summary> /// Determines whether the specified service type is registered. /// </summary> /// <param name="serviceType">The type of the service.</param> /// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param> /// <returns><c>true</c> if the specified service type is registered; otherwise, <c>false</c>.</returns> /// <remarks>Note that the actual implementation lays in the hands of the IoC technique being used.</remarks> /// <exception cref="ArgumentNullException">The <paramref name="serviceType"/> is <c>null</c>.</exception> public bool IsTypeRegistered(Type serviceType, object tag = null) { Argument.IsNotNull("serviceType", serviceType); var serviceInfo = new ServiceInfo(serviceType, tag); lock (this) { if (_registeredInstances.ContainsKey(serviceInfo)) { return(true); } if (_registeredTypes.ContainsKey(serviceInfo)) { return(true); } // CTL-161, support generic types if (serviceType.IsGenericTypeEx()) { var genericArguments = serviceType.GetGenericArgumentsEx().ToList(); var hasRealGenericArguments = (from genericArgument in genericArguments where !string.IsNullOrEmpty(genericArgument.FullName) select genericArgument).Any(); if (hasRealGenericArguments) { var genericType = serviceType.GetGenericTypeDefinitionEx(); var isOpenGenericTypeRegistered = IsTypeRegistered(genericType, tag); if (isOpenGenericTypeRegistered) { Log.Debug("An open generic type '{0}' is registered, registering new closed generic type '{1}' based on the open registration", genericType.GetSafeFullName(), serviceType.GetSafeFullName()); var registrationInfo = GetRegistrationInfo(genericType, tag); var finalType = registrationInfo.ImplementingType.MakeGenericType(genericArguments.ToArray()); RegisterType(serviceType, finalType, tag, registrationInfo.RegistrationType); return(true); } } } // CTL-271 Support generic lists (array specific type) // TODO: Can register, // Last resort var eventArgs = new MissingTypeEventArgs(serviceType); MissingType.SafeInvoke(this, eventArgs); if (eventArgs.ImplementingInstance != null) { Log.Debug("Late registering type '{0}' to instance of type '{1}' via MissingTypeEventArgs.ImplementingInstance", serviceType.FullName, eventArgs.ImplementingInstance.GetType().FullName); RegisterInstance(serviceType, eventArgs.ImplementingInstance, eventArgs.Tag, this); return(true); } if (eventArgs.ImplementingType != null) { Log.Debug("Late registering type '{0}' to type '{1}' via MissingTypeEventArgs.ImplementingType", serviceType.FullName, eventArgs.ImplementingType.FullName); RegisterType(serviceType, eventArgs.ImplementingType, eventArgs.Tag, eventArgs.RegistrationType, true, this, null); return(true); } } return(false); }
private IEnumerable <PawnKindDef> GenerateIfMissing(IEnumerable <PawnKindDef> workList, Func <PawnKindDef, bool> predicate, MissingType type, ThingDef race) { if (FactionProbablyNotGeneratedYet) { return(DefaultList); } workList = GetWorkListUsing(workList, predicate, out List <TechLevel> triedLevels, out TechLevel successLevel); string missingLabel0 = ResolveTypeToLabel0(type); if (!workList.Any(predicate)) { Log.Warning("noPawnKindDefOfTypeOfRaceError".Translate(missingLabel0, race.label.CapitalizeFirst())); workList = workList.Concat(DefaultList.Where(predicate)); } else if (triedLevels.Count != 0) { string missingLabel1 = ResolveTypeToLabel1(type); Log.Warning("noPawnKindDefOfTypeOfRaceWarning".Translate(missingLabel0, string.Join(", ", triedLevels), race.label.CapitalizeFirst(), missingLabel1, successLevel.ToString())); } return(workList); }
private static void FindInGO(GameObject go, MissingType missing) { _goCnt++; Component[] components = go.GetComponents <Component>(); for (int i = 0; i < components.Length; i++) { _componentsCnt++; Component comp = components[i]; if (comp == null) { if (missing == MissingType.Script) { _missingCnt++; Debug.Log(FullPathToGO(go) + " has an empty script attached in position: " + i, go); } } else { if (missing == MissingType.LinkInScript || missing == MissingType.AudioLinkInScript) { FieldInfo[] fields = comp.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); int fiCnt = fields.Length; for (int fiIdx = 0; fiIdx < fiCnt; ++fiIdx) { FieldInfo fi = fields[fiIdx]; System.Object value = fi.GetValue(comp) as System.Object; if (missing == MissingType.AudioLinkInScript) { System.Type elementType = fi.FieldType.GetElementType(); if (fi.FieldType != typeof(AudioClip) && !(fi.FieldType.IsArray && elementType == typeof(AudioClip))) { continue; } } if (IsBroken(value)) { _missingCnt++; Debug.Log(FullPathToGO(go) + " component " + comp.GetType() + " has broken link for " + fi.Name + " (" + fi.FieldType + ")", go); } else if (value != null && !value.Equals(null)) { if (fi.FieldType.IsSubclassOf(typeof(IList)) || fi.FieldType.IsSubclassOf(typeof(System.Array))) { IList list = value as IList; int listCnt = list.Count; for (int listIdx = 0; listIdx < listCnt; ++listIdx) { System.Object valueInList = list[listIdx]; if (IsBroken(valueInList)) { _missingCnt++; Debug.Log(FullPathToGO(go) + " component " + comp.GetType() + " has broken link in list " + fi.Name + " (" + fi.FieldType + ") on position " + listIdx, go); } } } } } } } } // Now recurse through each child GO (if there are any): foreach (Transform childT in go.transform) { //Debug.Log("Searching " + childT.name + " " ); FindInGO(childT.gameObject, missing); } }