/// <summary>
/// Creates a structurally equivalent union type from a given type.
/// </summary>
/// <param name="type">The type to copy the structure of.</param>
/// <returns>A structurally equivalent copy of the given type.</returns>
public static IStonUnionType Copy(IStonUnionType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
return(new StonUnionType(type));
}
/// <summary>
/// Determines whether two union types are equivalent.
/// </summary>
/// <param name="x">The first union type to compare.</param>
/// <param name="y">The second union type to compare.</param>
/// <returns>True when types are equivalent, false otherwise.</returns>
public bool Equals(IStonUnionType x, IStonUnionType y)
{
if (x == y)
{
return(true);
}
else if (x == null || y == null)
{
return(false);
}
return(x.PermittedTypes.SequenceEqual(y.PermittedTypes, this));
}
/// <summary>
/// Checks the validity of a given STON union type.
/// </summary>
/// <param name="type">The type to check the validity of.</param>
public static void ValidateType(IStonUnionType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (type.PermittedTypes == null || !type.PermittedTypes.Skip(1).Any())
{
throw new StonException("A union type must have at least two permitted types.");
}
if (type.PermittedTypes.Contains(null))
{
throw new StonException("A union type cannot have a non-existing permitted type.");
}
}
/// <summary>
/// Returns a hash code for a given union type.
/// </summary>
/// <param name="obj">The union type to get a hash code of.</param>
/// <returns>The hash code for the type.</returns>
public int GetHashCode(IStonUnionType obj)
{
if (obj == null)
{
return(0);
}
unchecked
{
int result = 17;
foreach (var parameter in obj.PermittedTypes)
{
result = result * 31 + GetHashCode(parameter);
}
return(result);
}
}
// writes a union type
private void WriteType(StonTokenWriter writer, IStonUnionType type)
{
bool first = true;
foreach (var permittedType in type.PermittedTypes)
{
if (!first)
{
writer.Write('|');
}
if (permittedType is IStonUnionType)
{
writer.Write('<');
}
WriteType(writer, permittedType);
if (permittedType is IStonUnionType)
{
writer.Write('>');
}
first = false;
}
}
/// <summary>
/// Creates a structurally equivalent union type from a given type.
/// </summary>
/// <param name="type">The type to copy the structure of.</param>
public StonUnionType(IStonUnionType type)
: this(type.PermittedTypes)
{
}
