internal ListReadContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be {nameof(IReadOnlyList<int>)}<>.", nameof(type));
}
ItemContract = contractCollection.GetOrAddReadContract(type.GetGenericArguments().Single());
}
internal NullableReadContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be nullable.", nameof(type));
}
Inner = contractCollection.GetOrAddReadContract(Nullable.GetUnderlyingType(type));
}
internal DictionaryReadContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be {nameof(IReadOnlyDictionary<int, int>)}<,>.", nameof(type));
}
KeyContract = contractCollection.GetOrAddReadContract(type.GetGenericArguments()[0]);
ValueContract = contractCollection.GetOrAddReadContract(type.GetGenericArguments()[1]);
}
internal NullableReadContract(IReadContract inner) => Inner = inner;
internal ListReadContract(IReadContract itemContract) => ItemContract = itemContract;
internal DictionaryReadContract(IReadContract keyContract, IReadContract valueContract)
{
KeyContract = keyContract;
ValueContract = valueContract;
}
public bool TryResolveReadContract(string str, out IReadContract readContract)
{
if (!AllowResolution)
{
throw new InvalidOperationException("Cannot resolve contract at this stage. Use a bind action instead.");
}
if (str.StartsWith("#"))
{
var id = str.Substring(1);
readContract = Contracts.OfType <ByRefContract>().SingleOrDefault(s => s.Id == id) as IReadContract;
return(readContract != null);
}
if (str.StartsWith("{"))
{
var tokens = ContractMarkupExtension.Tokenize(str).ToList();
// ReSharper disable once SwitchStatementMissingSomeCases
switch (tokens.Count)
{
case 1:
if (tokens[0] == "empty")
{
readContract = Intern(new EmptyContract());
return(true);
}
break;
case 2:
if (tokens[0] == "nullable")
{
if (TryResolveReadContract(tokens[1], out IReadContract inner))
{
readContract = Intern(new NullableReadContract(inner));
return(true);
}
}
else if (tokens[0] == "list")
{
if (TryResolveReadContract(tokens[1], out IReadContract itemContract))
{
readContract = Intern(new ListReadContract(itemContract));
return(true);
}
}
break;
case 3:
if (tokens[0] == "dictionary")
{
if (TryResolveReadContract(tokens[1], out IReadContract keyContract) && TryResolveReadContract(tokens[2], out IReadContract valueContract))
{
readContract = Intern(new DictionaryReadContract(keyContract, valueContract));
return(true);
}
}
break;
}
if (tokens.Count != 0 && tokens[0] == "tuple")
{
var itemContracts = new List <IReadContract>();
foreach (var token in tokens.Skip(1))
{
if (!TryResolveReadContract(token, out IReadContract itemContract))
{
readContract = null;
return(false);
}
itemContracts.Add(itemContract);
}
readContract = Intern(new TupleReadContract(itemContracts));
return(true);
}
readContract = null;
return(false);
}
readContract = Intern(new PrimitiveContract(str));
return(true);
}
/// <summary> /// Produced a reference string for <paramref name="contract"/>. /// </summary> /// <remarks> /// For more information on monikers, read the documentation of <see cref="ContractCollection"/>. /// </remarks> /// <param name="contract">The contract to return a reference string for.</param> /// <returns>The reference string.</returns> public static string ToReferenceString(this IReadContract contract) => ToReferenceStringInternal(contract);
