internal ListWriteContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be {nameof(IReadOnlyList<int>)}<>.", nameof(type));
}
ItemContract = contractCollection.GetOrAddWriteContract(type.GetGenericArguments().Single());
}
internal NullableWriteContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be nullable.", nameof(type));
}
Inner = contractCollection.GetOrAddWriteContract(Nullable.GetUnderlyingType(type));
}
internal DictionaryWriteContract(Type type, ContractCollection contractCollection)
{
if (!CanProcess(type))
{
throw new ArgumentException($"Type {type} must be {nameof(IReadOnlyDictionary<int, int>)}<,>.", nameof(type));
}
KeyContract = contractCollection.GetOrAddWriteContract(type.GetGenericArguments()[0]);
ValueContract = contractCollection.GetOrAddWriteContract(type.GetGenericArguments()[1]);
}
/// <inheritdoc />
public bool CanReadFrom(IWriteContract writeContract, bool strict)
{
if (!(writeContract is EnumContract that))
{
return(false);
}
return(strict
? _memberNames.SetEquals(that.MemberNames)
: _memberNames.IsSupersetOf(that.MemberNames));
}
internal Field(string name, IWriteContract contract)
{
Name = name;
Contract = contract;
}
internal NullableWriteContract(IWriteContract inner) => Inner = inner;
internal ListWriteContract(IWriteContract itemContract) => ItemContract = itemContract;
internal Member(string id, IWriteContract contract)
{
Id = id;
Contract = contract;
}
/// <inheritdoc /> public bool CanReadFrom(IWriteContract writeContract, bool strict) => writeContract is EmptyContract || !strict;
internal DictionaryWriteContract(IWriteContract keyContract, IWriteContract valueContract)
{
KeyContract = keyContract;
ValueContract = valueContract;
}
/// <inheritdoc />
public bool CanReadFrom(IWriteContract writeContract, bool strict)
{
return(writeContract is DictionaryWriteContract ws &&
KeyContract.CanReadFrom(ws.KeyContract, strict) &&
ValueContract.CanReadFrom(ws.ValueContract, strict));
}
/// <inheritdoc /> public bool CanReadFrom(IWriteContract writeContract, bool strict) => Equals(writeContract);
public bool TryResolveWriteContract(string str, out IWriteContract writeContract)
{
if (!AllowResolution)
{
throw new InvalidOperationException("Cannot resolve contract at this stage. Use a bind action instead.");
}
if (str.StartsWith("#"))
{
var id = str.Substring(1);
writeContract = Contracts.OfType <ByRefContract>().SingleOrDefault(s => s.Id == id) as IWriteContract;
return(writeContract != null);
}
if (str.StartsWith("{"))
{
var tokens = ContractMarkupExtension.Tokenize(str).ToList();
// ReSharper disable once SwitchStatementMissingSomeCases
switch (tokens.Count)
{
case 1:
if (tokens[0] == "empty")
{
writeContract = Intern(new EmptyContract());
return(true);
}
break;
case 2:
if (tokens[0] == "nullable")
{
if (TryResolveWriteContract(tokens[1], out IWriteContract inner))
{
writeContract = Intern(new NullableWriteContract(inner));
return(true);
}
}
else if (tokens[0] == "list")
{
if (TryResolveWriteContract(tokens[1], out IWriteContract itemContract))
{
writeContract = Intern(new ListWriteContract(itemContract));
return(true);
}
}
break;
case 3:
if (tokens[0] == "dictionary")
{
if (TryResolveWriteContract(tokens[1], out IWriteContract keyContract) && TryResolveWriteContract(tokens[2], out IWriteContract valueContract))
{
writeContract = Intern(new DictionaryWriteContract(keyContract, valueContract));
return(true);
}
}
break;
}
if (tokens.Count != 0 && tokens[0] == "tuple")
{
var itemContracts = new List <IWriteContract>();
foreach (var token in tokens.Skip(1))
{
if (!TryResolveWriteContract(token, out IWriteContract itemContract))
{
writeContract = null;
return(false);
}
itemContracts.Add(itemContract);
}
writeContract = Intern(new TupleWriteContract(itemContracts));
return(true);
}
writeContract = null;
return(false);
}
writeContract = 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 IWriteContract contract) => ToReferenceStringInternal(contract);
