/// <summary>
/// Converts the current reader value to an XML Document and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="setting"></param>
/// <returns></returns>
internal static object ToXmlDocument(XmlReader reader, Type requiredType, PDFGeneratorSettings setting)
{
XmlReader inner = reader.ReadSubtree();
System.Xml.XmlDocument doc = new XmlDocument();
return(doc);
}
/// <summary>
/// Converts the current reader value to an enumerated value (optionally based on the current settings culture) and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToEnum(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader);
if (string.IsNullOrEmpty(value))
{
return(DBNull.Value);
}
if (value.IndexOf(' ') > -1)
{
value = value.Replace(' ', ',');
}
object result;
if (Enum.TryParse(requiredType, value, true, out result))
{
return(result);
}
else if (settings.ConformanceMode == ParserConformanceMode.Lax)
{
settings.TraceLog.Add(TraceLevel.Error, "Parser", "Could not convert the value of " + value + " to a " + requiredType.Name);
return(DBNull.Value);
}
else
{
throw new ArgumentException("Could not convert the value of " + value + " to a " + requiredType.Name, "value");
}
}
/// <summary>
/// Converts the current reader value to a PDF Template and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToPDFTemplate(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
object obj = Activator.CreateInstance(settings.TempateGeneratorType);
IPDFTemplateGenerator gen = (IPDFTemplateGenerator)obj;
string content = reader.ReadInnerXml();
gen.InitTemplate(content, new System.Xml.XmlNamespaceManager(reader.NameTable));
return(gen);
}
/// <summary>
/// Converts the current reader value to a url (optionally based on the current settings culture) and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToUri(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader);
if (string.IsNullOrEmpty(value))
{
return(DBNull.Value);
}
return(new Uri(value));
}
/// <summary>
/// Converts the current reader value to a runtime type and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToType(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader);
string prefix;
string name;
int sep = value.IndexOf(':');
if (sep > 0)
{
name = value.Substring(sep + 1);
prefix = value.Substring(0, sep);
}
else
{
prefix = "";
name = value;
}
string ns = reader.LookupNamespace(prefix);
bool isremote;
ParserClassDefinition cdefn;
try
{
cdefn = ParserDefintionFactory.GetClassDefinition(name, ns, settings.ConformanceMode == ParserConformanceMode.Strict, out isremote);
}
catch (Exception ex)
{
throw new PDFParserException(string.Format(Errors.RuntimeTypeCouldNotBeDeterminedForReference, value), ex);
}
if (isremote)
{
if (settings.ConformanceMode == ParserConformanceMode.Strict)
{
throw new ArgumentOutOfRangeException("isremote", String.Format(Errors.CannotUseRemoteTypeReferencesInATypeAttribute, reader.Value));
}
else
{
settings.TraceLog.Add(TraceLevel.Error, "XML Parser", String.Format(Errors.CannotUseRemoteTypeReferencesInATypeAttribute, reader.Value));
return(null);
}
}
if (null == cdefn)
{
settings.TraceLog.Add(TraceLevel.Error, "XML Parser", String.Format(Errors.RuntimeTypeCouldNotBeDeterminedForReference, reader.Value));
return(typeof(NeverBeActivated));
}
else
{
return(cdefn.ClassType);
}
}
public object GetValue(System.Xml.XmlReader reader, PDFGeneratorSettings settings)
{
try
{
return(this.DoGetValue(reader, settings));
}
catch (Exception ex)
{
throw new PDFParserException("Could not read the value " + this.Name + " from the Xml source", ex);
}
}
/// <summary>
/// Converts the current reader value to an XPath Navigator and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToXPathNavigator(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.Comment)
{
reader.Read();
}
XmlReader inner = reader.ReadSubtree();
System.Xml.XPath.XPathNavigator nav = new System.Xml.XPath.XPathDocument(inner).CreateNavigator();
return(nav);
}
/// <summary>
/// Converts the current reader value to a char (optionally based on the current settings culture) and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToChar(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader);
if (string.IsNullOrEmpty(value))
{
return(DBNull.Value);
}
else
{
return(char.Parse(value));
}
}
/// <summary>
/// Converts the current reader value to a signed byte (optionally based on the current settings culture) and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToSByte(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader);
if (string.IsNullOrEmpty(value))
{
return(DBNull.Value);
}
if (settings.HasSpecificCulture)
{
return(sbyte.Parse(value, settings.SpecificCulture));
}
else
{
return(sbyte.Parse(value, System.Globalization.CultureInfo.InvariantCulture));
}
}
/// <summary>
/// Converts the current reader value to an XML Node and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="setting"></param>
/// <returns></returns>
internal static object ToXmlNode(XmlReader reader, Type requiredType, PDFGeneratorSettings setting)
{
while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.Comment)
{
reader.Read();
}
if (reader.NodeType == XmlNodeType.EndElement)
{
return(null); //blank value
}
else
{
XmlReader inner = reader.ReadSubtree();
System.Xml.XmlDocument doc = new XmlDocument();
doc.Load(inner);
return(doc.FirstChild);
}
}
/// <summary>
/// Converts the current reader value to dbnull (optionally based on the current settings culture) and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToDBNull(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
string value = GetReaderValue(reader); //still need to read ahead
return(DBNull.Value);
}
/// <summary>
/// Creates a full clone of these settings
/// </summary>
/// <returns></returns>
public PDFGeneratorSettings Clone()
{
PDFGeneratorSettings clone = this.MemberwiseClone() as PDFGeneratorSettings;
return(clone);
}
/// <summary>
/// Converts the current reader value to a string and returns it
/// </summary>
/// <param name="reader"></param>
/// <param name="requiredType"></param>
/// <param name="settings"></param>
/// <returns></returns>
internal static object ToString(XmlReader reader, Type requiredType, PDFGeneratorSettings settings)
{
return(GetReaderValue(reader));
}
/// <summary> /// Method so they convert from the current XMLReader value to the required type. Inheritors must override /// </summary> /// <param name="reader"></param> /// <param name="requiredType"></param> /// <param name="settings"></param> /// <returns></returns> internal abstract object ConvertXml(XmlReader reader, Type requiredType, PDFGeneratorSettings settings);
/// <summary>
/// Returns true if the value provided is an expression that matches the pattern required for a binding expression.
/// If it does value will be modified to be just the content of that expression and the bindingFactory will be set to the
/// factory that handles these expression types.
/// </summary>
/// <param name="value">The string to check if it is a binding expression. If it does match, then it will be modifed </param>
/// <param name="bindingfactory"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static bool IsBindingExpression(ref string value, out IPDFBindingExpressionFactory bindingfactory, PDFGeneratorSettings settings = null)
{
bindingfactory = null;
if (string.IsNullOrEmpty(value) || value.Length < 4)
{
return(false);
}
else if (!(value.StartsWith(BindingStartChar) && value.EndsWith(BindingEndChar)))
{
return(false);
}
else if (value.StartsWith(BindingStartEscape))
{
value = BindingStartChar + value.Substring(BindingStartEscape.Length);
return(false);
}
else
{
int separatorIndex = value.IndexOf(BindingKeySeparator);
if (separatorIndex < 0)
{
return(false);
}
string factoryKey = value.Substring(BindingStartChar.Length, separatorIndex - BindingStartChar.Length);
//ensure the factories are initialized (and will raise an appropriate exception that can be handled if not.
//doesn't need to be thread safe as it will simply reset the collection.
if (null == _configFactories)
{
_configFactories = InitFactories();
}
if (_configFactories.TryGetValue(factoryKey, out bindingfactory))
{
int offset = BindingStartChar.Length + factoryKey.Length + BindingKeySeparator.Length;
int len = value.Length - (offset + 1);
value = value.Substring(offset, len);
return(true);
}
else if (null != settings)
{
settings.TraceLog.Add(TraceLevel.Warning, "XML Parser", string.Format(Errors.BindingPrefixIsNotKnown, factoryKey, value));
return(false);
}
else
{
return(false);
}
}
}
public IPDFParser CreateParser(PDFGeneratorSettings settings)
{
return(new PDFXMLParser(settings));
}
/// <summary>
/// Returns true if the value provided is an expression that matches the pattern required for a binding expression.
/// If it does value will be modified to be just the content of that expression and the bindingFactory will be set to the
/// factory that handles these expression types.
/// </summary>
/// <param name="value">The string to check if it is a binding expression. If it does match, then it will be modifed </param>
/// <param name="bindingfactory"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static bool IsBindingExpression(ref string value, out IPDFBindingExpressionFactory bindingfactory, PDFGeneratorSettings settings = null)
{
bindingfactory = null;
if (!value.Contains(BindingStartChar))
{
return(false);
}
else if (value.StartsWith(BindingStartChar) && value.EndsWith(BindingEndChar))
{
return(TryGetBindingExpression(ref value, out bindingfactory, settings));
}
else if (value.Contains(BindingDoubleSeparator))
{
var match = handlebarsMatcher.Match(value);
if (match == null || match.Success == false)
{
return(false);
}
if (null == _configFactories)
{
_configFactories = InitFactories();
}
if (!_configFactories.TryGetValue(HandlebarsExpressionBindingKey, out bindingfactory))
{
if (null != settings)
{
settings.TraceLog.Add(TraceLevel.Error, "Binding", "Handlebars expression factorys has not been initialized with the key " + HandlebarsExpressionBindingKey);
}
return(false);
}
var pos = 0;
StringBuilder sb = new StringBuilder();
var quoteChar = "\"";
while (match != null && match.Success)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
else
{
sb.Append("concat(");
}
string sub;
if (match.Index > pos)
{
sub = value.Substring(pos, match.Index - pos);
sb.Append(quoteChar);
sb.Append(sub);
sb.Append(quoteChar);
sb.Append(", ");
}
sub = match.Value;
sb.Append(sub.Substring(HandlebarsExpressionInset, sub.Length - HandlebarsExpressionLength));
pos = match.Index + match.Value.Length;
match = match.NextMatch();
}
if (pos < value.Length)
{
sb.Append(", ");
sb.Append(quoteChar);
sb.Append(value.Substring(pos));
sb.Append(quoteChar);
}
sb.Append(")");
value = sb.ToString();
return(true);
}
else
{
return(false);
}
}
protected override object DoGetValue(XmlReader reader, PDFGeneratorSettings settings)
{
return(this.Converter(reader, this.PropertyInfo.PropertyType, settings));
}
protected virtual object DoGetValue(System.Xml.XmlReader reader, PDFGeneratorSettings settings)
{
throw new NotSupportedException("GetValue is not supported on the root property type");
}
