protected override int?GetChildrenPriority(IUnparser unparser, object astValue, Unparser.Children children, Unparser.Direction direction)
{
UnparsableAst mainChild = children.Single(childValue => IsMainChild(childValue.BnfTerm));
if (astValue.GetType() == this.domainType)
{
return(unparser.GetPriority(mainChild));
}
else
{
IBnfiTerm mainChildWithDomainType = mainChild.BnfTerm as IBnfiTerm;
if (mainChildWithDomainType == null || mainChildWithDomainType.DomainType == null)
{
throw new UnparseException(string.Format("Cannot unparse '{0}' (type: '{1}'). BnfTerm '{2}' is not an IBnfiTerm or it has no domain type.",
astValue, astValue.GetType().Name, mainChild.BnfTerm));
}
int?priority = mainChildWithDomainType.DomainType == typeof(object)
? int.MinValue
: 0 - mainChildWithDomainType.DomainType.GetInheritanceDistance(astValue);
Unparser.tsPriorities.Indent();
priority.DebugWriteLinePriority(Unparser.tsPriorities, mainChild);
Unparser.tsPriorities.Unindent();
return(priority);
}
}
public static BnfiTermConversion <TDOut> ConvertOptRef <TDIn, TDOut>(IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter,
ValueConverter <TDOut, TDIn> inverseValueConverterForUnparse, TDOut defaultValue)
where TDIn : class
where TDOut : class
{
return(ConvertOpt(bnfiTerm, valueConverter, inverseValueConverterForUnparse, defaultValue));
}
public static BnfiTermConversion <TDOut> ConvertOptVal <TDIn, TDOut>(IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter,
ValueConverter <TDOut, TDIn> inverseValueConverterForUnparse, TDOut defaultValue)
where TDIn : struct
where TDOut : struct
{
return(ConvertOpt <TDIn, TDOut>(bnfiTerm, valueConverter, inverseValueConverterForUnparse, defaultValue));
}
public static BnfiTermConversion <TDOut> Convert <TDIn, TDOut>(IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter, ValueConverter <TDOut, TDIn> inverseValueConverterForUnparse)
{
return(new BnfiTermConversion <TDOut>(
bnfiTerm.AsBnfTerm(),
ConvertValueConverterToValueIntroducer(valueConverter),
CastValueConverter <TDOut, TDIn, TDOut, object>(inverseValueConverterForUnparse),
defaultValue: default(TDOut),
isOptionalValue: false,
name: typeof(TDIn).Name.ToLower() + "_convertTo_" + typeof(TDOut).Name.ToLower(),
astForChild: true
));
}
public static MemberTL Bind <TMemberType, TValueType>(Expression <Func <TMemberType> > exprForFieldOrPropertyAccess, IBnfiTerm <TValueType> bnfiTerm)
where TValueType : TMemberType
{
return(Bind(exprForFieldOrPropertyAccess, bnfiTerm.AsBnfTerm()));
}
public static BnfiTermConversion <TDOut> Cast <TDIn, TDOut>(this IBnfiTerm <TDIn> bnfTerm, IBnfiTerm <TDOut> dummyBnfTerm)
{
return(BnfiTermConversion.Cast <TDIn, TDOut>(bnfTerm));
}
public static BnfiTermConversion <TDOut> Cast <TDIn, TDOut>(IBnfiTerm <TDIn> bnfTerm)
{
return(Convert(bnfTerm, IdentityFunctionForceCast <TDIn, TDOut>, IdentityFunctionForceCast <TDOut, TDIn>));
}
public static BnfiTermConversion <TDOut> ConvertValue <TDIn, TDOut>(this IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter,
ValueConverter <TDOut, TDIn> inverseValueConverterForUnparse)
{
return(BnfiTermConversion.Convert(bnfiTerm, valueConverter, inverseValueConverterForUnparse));
}
public static BnfiTermConversion <TDOut> ConvertOptRef <TDIn, TDOut>(IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter, TDOut defaultValue)
where TDIn : class
where TDOut : class
{
return(ConvertOptRef <TDIn, TDOut>(bnfiTerm, valueConverter, NoUnparseByInverse <TDOut, TDIn>(), defaultValue));
}
public static BnfiTermCopy <TDerived> Copy <TBase, TDerived>(IBnfiTermCopyable <TBase> bnfiTerm, IBnfiTerm <TDerived> dummyBnfiTerm)
where TDerived : TBase
{
return(Copy <TBase, TDerived>(bnfiTerm));
}
public static BnfiTermCollection <List <TElementType>, TElementType> PlusList <TElementType>(IBnfiTerm <TElementType> bnfTermElement, BnfTerm delimiter = null)
{
return(PlusList <List <TElementType>, TElementType>(bnfTermElement, delimiter));
}
public static Member <TDeclaringType> Bind <TDeclaringType, TMemberElementType, TValueElementType>(IBnfiTerm <TDeclaringType> dummyBnfiTerm,
Expression <Func <TDeclaringType, IList <TMemberElementType> > > exprForFieldOrPropertyAccess, IBnfiTerm <IEnumerable <TValueElementType> > bnfiTerm)
where TValueElementType : TMemberElementType
{
return(Bind(exprForFieldOrPropertyAccess, bnfiTerm.AsBnfTerm()));
}
public static BnfiTermConversion <T?> QVal <T>(this IBnfiTerm <T> bnfTerm)
where T : struct
{
return(BnfiTermConversion.ConvertOptVal(bnfTerm));
}
public static BnfiTermConversion <TDOut> Convert <TDIn, TDOut>(IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter)
{
return(Convert <TDIn, TDOut>(bnfiTerm, valueConverter, NoUnparseByInverse <TDOut, TDIn>()));
}
public static MemberTL Bind <TMemberElementType, TValueElementType>(Expression <Func <IList <TMemberElementType> > > exprForFieldOrPropertyAccess,
IBnfiTerm <IEnumerable <TValueElementType> > bnfiTerm)
where TValueElementType : TMemberElementType
{
return(Bind(exprForFieldOrPropertyAccess, bnfiTerm.AsBnfTerm()));
}
public static BnfiTermCollection <TCollectionType, TElementType> PlusList <TCollectionType, TElementType>(this IBnfiTerm <TElementType> bnfTermElement, BnfTerm delimiter = null)
where TCollectionType : ICollection <TElementType>, new()
{
return(BnfiTermCollection.PlusList <TCollectionType, TElementType>(bnfTermElement, delimiter));
}
public static BnfiTermCollection <List <TElementType>, TElementType> StarList <TElementType>(this IBnfiTerm <TElementType> bnfTermElement, BnfTerm delimiter = null)
{
return(BnfiTermCollection.StarList(bnfTermElement, delimiter));
}
public static BnfiTermConversion <T> QRef <T>(this IBnfiTerm <T> bnfTerm, T defaultValue)
where T : class
{
return(BnfiTermConversion.ConvertOptRef(bnfTerm, defaultValue));
}
public static BnfiTermConversion <T> QVal <T>(this IBnfiTerm <T> bnfTerm, T defaultValue)
where T : struct
{
return(BnfiTermConversion.ConvertOptVal(bnfTerm, defaultValue));
}
public static BnfiTermConversion <T> QRef <T>(this IBnfiTerm <T> bnfTerm)
where T : class
{
return(BnfiTermConversion.ConvertOptRef(bnfTerm));
}
public static Member <TDeclaringType> Bind <TDeclaringType, TMemberType, TValueType>(IBnfiTerm <TDeclaringType> dummyBnfiTerm,
Expression <Func <TDeclaringType, TMemberType> > exprForFieldOrPropertyAccess, IBnfiTerm <TValueType> bnfiTerm)
where TValueType : TMemberType
{
return(Bind(exprForFieldOrPropertyAccess, bnfiTerm));
}
public static BnfiTermConversion <TDOut?> ConvertOptVal <TDIn, TDOut>(IBnfiTerm <TDIn> bnfTerm, ValueConverter <TDIn, TDOut> valueConverter)
where TDIn : struct
where TDOut : struct
{
return(ConvertOptVal <TDIn, TDOut>(bnfTerm, valueConverter, NoUnparseByInverse <TDOut, TDIn>()));
}
public static Member <TDeclaringType> Bind <TDeclaringType, TMemberType>(Expression <Func <TDeclaringType, TMemberType> > exprForFieldOrPropertyAccess,
IBnfiTerm <TDeclaringType> dummyBnfiTerm, IBnfiTermTL bnfiTerm)
{
return(Bind(exprForFieldOrPropertyAccess, bnfiTerm.AsBnfTerm()));
}
public static BnfiTermConversion <TDOut?> ConvertOptVal <TDIn, TDOut>(IBnfiTerm <TDIn> bnfTerm, ValueConverter <TDIn, TDOut> valueConverter, ValueConverter <TDOut, TDIn> inverseValueConverterForUnparse)
where TDIn : struct
where TDOut : struct
{
return(ConvertOpt <TDIn, TDOut?>(bnfTerm, value => valueConverter(value), value => inverseValueConverterForUnparse(value.Value)));
}
public static BnfiTermCollection <TCollectionType, TElementType> MakeStarRule <TCollectionType, TElementType>(BnfiTermCollection <TCollectionType, TElementType> bnfiTermCollection, BnfTerm delimiter, IBnfiTerm <TElementType> element)
where TCollectionType : ICollection <TElementType>, new()
{
return(BnfiTermCollection.MakeStarRule(bnfiTermCollection, delimiter, element));
}
public static BnfiTermConversion <T> ConvertOptVal <T>(IBnfiTerm <T> bnfiTerm, T defaultValue)
where T : struct
{
return(ConvertOptVal(bnfiTerm, value => value, value => value, defaultValue));
}
public static BnfiTermCollection <TCollectionType, TElementType> PlusList <TCollectionType, TElementType>(IBnfiTerm <TElementType> bnfTermElement, BnfTerm delimiter = null)
where TCollectionType : ICollection <TElementType>, new()
{
var bnfiTermCollection = BnfiTermCollection <TCollectionType, TElementType> .CreateContractible();
MakePlusRule(bnfiTermCollection, delimiter, bnfTermElement);
return(bnfiTermCollection);
}
public static BnfiTermConversion <T> ConvertOptRef <T>(IBnfiTerm <T> bnfiTerm, T defaultValue)
where T : class
{
return(ConvertOptRef(bnfiTerm, value => value, value => value, defaultValue));
}
internal static BnfiTermCollection <TCollectionType, TElementType> MakeStarRule <TCollectionType, TElementType>(BnfiTermCollection <TCollectionType, TElementType> bnfiTermCollection, BnfTerm delimiter, IBnfiTerm <TElementType> element)
where TCollectionType : ICollection <TElementType>, new()
{
return((BnfiTermCollection <TCollectionType, TElementType>)_MakeStarRule(bnfiTermCollection, delimiter, element.AsBnfTerm()));
}
public static BnfiTermConversion <TDOut> ConvertValue <TDIn, TDOut>(this IBnfiTerm <TDIn> bnfiTerm, ValueConverter <TDIn, TDOut> valueConverter)
{
return(BnfiTermConversion.Convert(bnfiTerm, valueConverter));
}
