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