public ResolveResultConverterStrategyTuple(Type tupleType)
: base(tupleType)
{
_componentStrategies = HarshTuple.GetComponentTypes(tupleType)
.Select(GetNestedTupleStrategy)
.ToImmutableArray();
}
public override Object ConvertNestedComponents(IEnumerator <Object> componentEnumerator)
=> HarshTuple.Create(
ResultType,
_componentStrategies.Select(
s => s.ConvertNestedComponents(componentEnumerator)
)
);
private ResolveResultConverterStrategy GetNestedTupleStrategy(Type t)
{
if (HarshGrouping.IsGroupingType(t))
{
throw Logger.Fatal.ArgumentFormat(
nameof(t),
SR.ResolveResultConverterStrategyTuple_NestedGroupingNotAllowed,
ResultType
);
}
if (HarshTuple.IsTupleType(t))
{
return(new ResolveResultConverterStrategyTuple(t));
}
return(ResolveResultConverterStrategyUnpack.Instance);
}
private static void AddComponentsFlat(ImmutableArray <Type> .Builder result, Type t)
{
if (HarshTuple.IsTupleType(t))
{
foreach (var ct in HarshTuple.GetComponentTypes(t))
{
AddComponentsFlat(result, ct);
}
}
else if (HarshGrouping.IsGroupingType(t))
{
AddComponentsFlat(result, t.GenericTypeArguments[0]);
AddComponentsFlat(result, t.GenericTypeArguments[1]);
}
else
{
result.Add(t);
}
}
internal static ResolveResultConverterStrategy GetStrategyForType(Type type)
{
if (type == null)
{
throw Logger.Fatal.ArgumentNull(nameof(type));
}
if (HarshGrouping.IsGroupingType(type))
{
return(new ResolveResultConverterStrategyGrouping(type));
}
if (HarshTuple.IsTupleType(type))
{
return(new ResolveResultConverterStrategyTuple(type));
}
return(ResolveResultConverterStrategyUnpack.Instance);
}
public void MakeTupleType_fails_empty()
{
Assert.Throws <ArgumentException>(
() => HarshTuple.MakeTupleType()
);
}
public void MakeTupleType_fails_nine_Qs()
{
Assert.Throws <ArgumentException>(
() => HarshTuple.MakeTupleType(NineQs)
);
}
public void IsTupleType_is_false_for_non_tuples(Type type)
{
Assert.False(HarshTuple.IsTupleType(type));
}
public void MakeTupleType_makes_tuple_type(Type expected, params Type[] args)
{
Assert.Equal(expected, HarshTuple.MakeTupleType(args));
}
public void IsTupleType_is_true_for_tuples(Type type)
{
Assert.True(HarshTuple.IsTupleType(type));
}
public void GetComponentTypes_returns_components(Type t, Type[] expected)
{
Assert.Equal(expected, HarshTuple.GetComponentTypes(t));
}
public void GetComponentTypes_fails_for_unconstructed_tuple(Type t)
{
Assert.Throws <ArgumentException>(
() => HarshTuple.GetComponentTypes(t)
);
}
public void MakeTupleType_creates_nested_tuple_eighteen()
{
var actual = HarshTuple.MakeTupleType(EighteenQs);
Assert.Equal(EighteenQsType, actual);
}
public void MakeTupleType_creates_nested_tuple_nine()
{
var actual = HarshTuple.MakeTupleType(NineQs);
Assert.Equal(NineQsType, actual);
}
