internal void Resolve()
{
if (_resolved)
{
return;
}
Resolver resolver = new Resolver();
resolver.SetParameter("solution", this);
resolver.Resolve(this);
if (PerforceRootPath != null)
{
Util.ResolvePath(SharpmakeCsPath, ref _perforceRootPath);
}
foreach (Solution.Configuration conf in Configurations)
{
conf.Resolve(resolver);
}
foreach (var extraItemKey in ExtraItems.Keys.ToList())
{
Strings values = new Strings(ExtraItems[extraItemKey]);
foreach (string value in values)
{
string newValue = resolver.Resolve(value);
values.UpdateValue(value, newValue);
}
ExtraItems[extraItemKey] = values;
}
_resolved = true;
}
internal void Resolve()
{
if (_resolved)
{
return;
}
using (Builder.Instance.CreateProfilingScope("ResolveSolution"))
{
Resolver resolver = new Resolver();
resolver.SetParameter("solution", this);
resolver.Resolve(this);
foreach (Solution.Configuration conf in Configurations)
{
conf.Resolve(resolver);
}
foreach (var extraItemKey in ExtraItems.Keys.ToList())
{
Strings values = new Strings(ExtraItems[extraItemKey]);
foreach (string value in values)
{
string newValue = resolver.Resolve(value);
values.UpdateValue(value, newValue);
}
ExtraItems[extraItemKey] = values;
}
_resolved = true;
}
}
internal static void ResolvePathAndFixCase(string root, ref Strings paths)
{
List <string> sortedPaths = paths.Values;
foreach (string path in sortedPaths)
{
string fixedCase = ResolvePathAndFixCase(root, path);
paths.UpdateValue(path, fixedCase);
}
}
public static void ResolvePath(string root, ref Strings paths)
{
List <string> sortedPaths = paths.Values;
foreach (string path in sortedPaths)
{
string resolvedPath = ResolvePath(root, path);
paths.UpdateValue(path, resolvedPath);
}
}
private void ResolveMember(string objectPath, object obj, MemberInfo memberInfo, object fallbackValue)
{
if (memberInfo.MemberType != MemberTypes.Field && memberInfo.MemberType != MemberTypes.Property)
{
return;
}
string memberPath;
if (objectPath != null)
{
memberPath = objectPath + _pathSeparator + memberInfo.Name;
}
else
{
memberPath = memberInfo.Name;
}
if (GetResolveStatus(memberPath) == ResolveStatus.Resolved)
{
return;
}
if (memberInfo.IsDefined(typeof(SkipResolveOnMember), false))
{
return;
}
if (memberInfo.MemberType == MemberTypes.Field)
{
FieldInfo fieldInfo = memberInfo as FieldInfo;
object fieldValue = fieldInfo.GetValue(obj);
if (fieldValue != null)
{
if (fieldInfo.FieldType == typeof(string))
{
if (CanWriteFieldValue(fieldInfo))
{
SetResolving(memberPath);
string value = fieldValue as string;
fieldInfo.SetValue(obj, Resolve(value, fallbackValue));
SetResolved(memberPath);
}
}
else if (fieldInfo.FieldType == typeof(Strings))
{
if (CanWriteFieldValue(fieldInfo))
{
SetResolving(memberPath);
Strings values = fieldValue as Strings;
if (values != null)
{
foreach (string value in values.Values)
{
string newValue = Resolve(value, fallbackValue);
values.UpdateValue(value, newValue);
}
}
SetResolved(memberPath);
}
}
else if (fieldValue is IList <string> )
{
if (CanWriteFieldValue(fieldInfo))
{
SetResolving(memberPath);
IList <string> values = fieldValue as IList <string>;
for (int i = 0; i < values.Count; ++i)
{
values[i] = Resolve(values[i], fallbackValue);
}
SetResolved(memberPath);
}
}
else if (fieldInfo.FieldType.IsClass)
{
object memberObject = fieldValue;
ResolveObject(memberPath, memberObject, fallbackValue);
}
}
}
else if (memberInfo.MemberType == MemberTypes.Property)
{
PropertyInfo propertyInfo = memberInfo as PropertyInfo;
if (propertyInfo.CanRead)
{
object propertyValue = propertyInfo.GetValue(obj, null);
if (propertyValue != null)
{
if (propertyInfo.PropertyType == typeof(string))
{
if (propertyInfo.CanWrite && propertyInfo.CanRead)
{
SetResolving(memberPath);
string value = propertyValue as string;
propertyInfo.SetValue(obj, Resolve(value, fallbackValue), null);
SetResolved(memberPath);
}
}
else if (propertyInfo.PropertyType == typeof(Strings))
{
SetResolving(memberPath);
Strings values = propertyValue as Strings;
foreach (string value in values.Values)
{
string newValue = Resolve(value, fallbackValue);
values.UpdateValue(value, newValue);
}
SetResolved(memberPath);
}
else if (propertyValue is IList <string> )
{
SetResolving(memberPath);
IList <string> values = propertyValue as IList <string>;
for (int i = 0; i < values.Count; ++i)
{
values[i] = Resolve(values[i], fallbackValue);
}
SetResolved(memberPath);
}
else if (propertyInfo.PropertyType.IsClass)
{
ResolveObject(memberPath, propertyValue, fallbackValue);
}
}
}
}
}