internal ParserAttributeDefinition(string name, string ns, PropertyInfo info, PDFXmlConverter convert, bool iscustomparsable, bool isBindOnly)
: base(name, ns, info, DeclaredParseType.Attribute)
{
this._converter = convert;
this._customparse = iscustomparsable;
this._iscodedom = Array.IndexOf <Type>(info.PropertyType.GetInterfaces(), typeof(IPDFSimpleExpressionValue)) > -1;
this._isBindableOnly = isBindOnly;
}
/// <summary>
/// Retrurns true and an XML converter to convert a reader value to the required type.
/// </summary>
/// <param name="type"></param>
/// <param name="convert"></param>
/// <param name="iscustom"></param>
/// <returns></returns>
private static bool IsCustomParsableType(Type type, out PDFXmlConverter convert, out bool iscustom)
{
PDFParsableValueAttribute valattr = GetCustomAttribute <PDFParsableValueAttribute>(type, true);
if (null != valattr)
{
iscustom = true;
convert = ConverterXml.GetParsableXmlConverter(type);
return(null != convert);
}
else
{
iscustom = false;
convert = null;
return(false);
}
}
/// <summary>
/// Checks whether the specified type is a known type.
/// Known types have pre-defined converters to take Xml content and convert to the correct value.
/// This method will return a converter for an xml reader
/// </summary>
/// <param name="type"></param>
/// <param name="xmlconvert">If the return value is true then the xmlconvert value will be set to a delegate that should be able to convert the current node to the proper type</param>
/// <returns></returns>
private static bool IsKnownType(Type type, out PDFXmlConverter xmlconvert)
{
bool result = false;
if (type.IsEnum)
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToEnum);
return(true);
}
TypeCode code = Type.GetTypeCode(type);
switch (code)
{
case TypeCode.Boolean:
xmlconvert = new PDFXmlConverter(ConverterXml.ToBool);
result = true;
break;
case TypeCode.Byte:
xmlconvert = new PDFXmlConverter(ConverterXml.ToByte);
result = true;
break;
case TypeCode.Char:
xmlconvert = new PDFXmlConverter(ConverterXml.ToChar);
result = true;
break;
case TypeCode.DBNull:
xmlconvert = new PDFXmlConverter(ConverterXml.ToDBNull);
result = true;
break;
case TypeCode.DateTime:
xmlconvert = new PDFXmlConverter(ConverterXml.ToDateTime);
result = true;
break;
case TypeCode.Decimal:
xmlconvert = new PDFXmlConverter(ConverterXml.ToDecimal);
result = true;
break;
case TypeCode.Double:
xmlconvert = new PDFXmlConverter(ConverterXml.ToDouble);
result = true;
break;
case TypeCode.Int16:
xmlconvert = new PDFXmlConverter(ConverterXml.ToInt16);
result = true;
break;
case TypeCode.Int32:
xmlconvert = new PDFXmlConverter(ConverterXml.ToInt32);
result = true;
break;
case TypeCode.Int64:
xmlconvert = new PDFXmlConverter(ConverterXml.ToInt64);
result = true;
break;
case TypeCode.SByte:
xmlconvert = new PDFXmlConverter(ConverterXml.ToSByte);
result = true;
break;
case TypeCode.Single:
xmlconvert = new PDFXmlConverter(ConverterXml.ToFloat);
result = true;
break;
case TypeCode.String:
xmlconvert = new PDFXmlConverter(ConverterXml.ToString);
result = true;
break;
case TypeCode.UInt16:
xmlconvert = new PDFXmlConverter(ConverterXml.ToUInt16);
result = true;
break;
case TypeCode.UInt32:
xmlconvert = new PDFXmlConverter(ConverterXml.ToUInt32);
result = true;
break;
case TypeCode.UInt64:
xmlconvert = new PDFXmlConverter(ConverterXml.ToUInt64);
result = true;
break;
case TypeCode.Object:
if (type == typeof(Guid))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToGuid);
result = true;
}
else if (type == typeof(DateTime))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToDateTime);
result = true;
}
else if (type == typeof(TimeSpan))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToTimeSpan);
result = true;
}
else if (type == typeof(Uri))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToUri);
result = true;
}
else if (type == typeof(Type))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToType);
result = true;
}
else if (type == typeof(System.Xml.XPath.IXPathNavigable))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToXPathNavigable);
result = true;
}
else if (type == typeof(System.Xml.XPath.XPathNavigator))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToXPathNavigator);
result = true;
}
else if (type == typeof(System.Xml.XmlNode))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToXmlNode);
result = true;
}
else if (type == typeof(IPDFTemplate))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToPDFTemplate);
result = true;
}
else if (type == typeof(System.Xml.XmlDocument))
{
xmlconvert = new PDFXmlConverter(ConverterXml.ToXmlDocument);
result = true;
}
else
{
xmlconvert = null;
result = false;
}
break;
case TypeCode.Empty:
default:
xmlconvert = null;
result = false;
break;
}
return(result);
}
/// <summary>
/// Protecxted constructor that accepts the type and
/// </summary>
/// <param name="parsetype"></param>
protected ParseableConverter(Type parsetype)
{
this.Type = parsetype;
XmlConverter = new PDFXmlConverter(this.ConvertXml);
ValueConverter = new PDFValueConverter(this.ConvertValue);
}
public ParserSimpleElementDefinition(string name, string ns, PropertyInfo pi, PDFXmlConverter convert, bool iscustomparsable)
: base(name, ns, pi, DeclaredParseType.SimpleElement)
{
this._convert = convert;
this._customparse = iscustomparsable;
}
