private bool TrySetSerializationParameter([NotNull] XdmWriterSettings serializerSettings,
[NotNull] XmlQualifiedName key,
[NotNull] string value)
{
Assert.ArgumentNotNull(serializerSettings, "serializerSettings");
Assert.ArgumentNotNull(key, "key");
Assert.ArgumentNotNull(value, "value");
try
{
if (serializerSettings.SetParameter(key, value))
{
Log.LogMessage(MessageImportance.Low,
Resources.AddingSerializationParameter,
key,
value);
}
else
{
Log.LogWarning(Resources.UnrecognisedSerializationParameter, key, value);
}
}
catch (XdmException e)
{
LogXdmException(Severity.Error, e.InnerException);
return(false);
}
return(true);
}
/// <summary>
/// Performs the serialization.
/// </summary>
/// <returns>
/// Returns <see langword="true" /> if the task successfully executed; otherwise, <see langword="false" />.
/// </returns>
protected override bool Process()
{
if (PopulateSchemaSet() == false)
{
return(false);
}
var documentSet = GetDocumentSet();
var contextItem = LoadContextItem(documentSet, Input);
if (contextItem == null)
{
return(false);
}
var serializationSettings = new XdmWriterSettings();
if (!SetSerializationSettings(serializationSettings))
{
return(false);
}
using (Stream outputStream = File.Create(Output.ItemSpec))
XdmWriter.Serialize(contextItem.CreateNavigator(), outputStream, serializationSettings);
OutputFiles = new[] { Output };
return(true);
}
public XmlWriter Resolve(string resultDocumentUri,
XdmWriterSettings settings)
{
Assert.ArgumentNotNull(resultDocumentUri, "resultDocumentUri");
Assert.ArgumentNotNull(settings, "settings");
settings.CloseOutput = true;
var uri = new Uri(new Uri(_baseOutputUri), resultDocumentUri);
if (uri.Scheme !=
Uri.UriSchemeFile)
{
_task.Log.LogError(Resources.CannotCreateResultDocument,
resultDocumentUri);
return(null);
}
var fileInfo = new AnyUri(resultDocumentUri).Normalize() == _baseOutputUri
? _primaryOutput
: new FileInfo(uri.LocalPath);
if (fileInfo == null)
{
_task.Log.LogMessage(MessageImportance.Low,
Resources.DiscardingPrimaryResultDocument,
resultDocumentUri);
return(null);
}
return(CreateResultDocument(settings, fileInfo));
}
private XmlWriter CreateResultDocument([NotNull] XdmWriterSettings settings,
[NotNull] FileInfo fileInfo)
{
Assert.ArgumentNotNull(settings, "settings");
Assert.ArgumentNotNull(fileInfo, "fileInfo");
_task.Log.LogMessage(MessageImportance.Low, Resources.CreateResultDocument, fileInfo.FullName);
var taskItem = new TaskItem(fileInfo.FullName);
var directory = fileInfo.Directory;
if (directory != null && directory.Exists == false)
{
directory.Create();
}
var localPath = fileInfo.FullName;
var stream = GetTemporaryFile(localPath);
var name = stream.Name;
taskItem.SetMetadata("MimeType", settings.MediaType ?? string.Empty);
taskItem.SetMetadata("Encoding", settings.Encoding);
// Record that, on failure, we must delete the newly created file.
_log.Add(UndoCreateAction(name, stream));
// Record that, on completion, we need to move the temporary file to the actual file.
_onComplete.Add(ReplaceAction(name, localPath, taskItem));
return(XdmWriter.Create(stream, settings));
}
/// <summary>
/// Executes the query.
/// </summary>
/// <returns>
/// Returns <see langword="true" /> if the task successfully executed; otherwise, <see langword="false" />.
/// </returns>
protected override bool Process()
{
if (PopulateSchemaSet() == false)
{
return(false);
}
var includeSettings = new XIncludeSettings
{
DocumentSet = GetDocumentSet(),
FixupXmlBase = BaseUriFixup,
FixupXmlLang = LanguageFixup
};
var contextItem = LoadContextItem(includeSettings.DocumentSet, Input);
if (contextItem == null)
{
return(false);
}
var serializationSettings = new XdmWriterSettings();
if (!SetSerializationSettings(serializationSettings))
{
return(false);
}
using (Stream outputStream = File.Create(Output.ItemSpec))
XInclude.Process(contextItem.CreateNavigator(), outputStream, serializationSettings, includeSettings);
OutputFiles = new[] { Output };
return(true);
}
private void Explain([NotNull] XQuery query)
{
Assert.ArgumentNotNull(query, "query");
Assert.IsNotNull(Plan, "Plan");
var settings = new XdmWriterSettings
{
Indent = true
};
var stream = File.OpenWrite(Plan.GetMetadata("FullPath"));
using (var xdmWriter = XdmWriter.Create(stream, settings))
query.Explain(xdmWriter);
}
private void Explain([NotNull] Xslt transform)
{
Assert.ArgumentNotNull(transform, "transform");
Assert.IsNotNull(Plan, "Plan");
var settings = new XdmWriterSettings
{
Indent = true
};
var stream = File.OpenWrite(Plan.GetMetadata("FullPath"));
using (var xdmWriter = XdmWriter.Create(stream, settings))
transform.Explain(xdmWriter);
}
/// <summary>
/// Sets the serialization parameters from from the <see cref = "SerializationParameters" /> property.
/// </summary>
/// <param name = "serializerSettings">An <see cref = "XdmWriterSettings" /> instance.</param>
/// <returns><see langword = "true" /> if setting serialization parameters was successful; otherwise, <see langword = "false" />.</returns>
protected bool SetSerializationSettings([NotNull] XdmWriterSettings serializerSettings)
{
Assert.ArgumentNotNull(serializerSettings, "serializerSettings");
var xmlReaderSettings = new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Fragment
};
if (SerializationParameterDocument != null)
{
Log.LogMessage(MessageImportance.Low,
Resources.SettingSerializationParameter,
SerializationParameterDocument.ItemSpec);
var path = SerializationParameterDocument.GetMetadata("FullPath");
using (var reader = XmlReader.Create(path, xmlReaderSettings))
serializerSettings.ParameterDocument(reader);
}
if (string.IsNullOrEmpty(SerializationParameters))
{
return(true);
}
try
{
using (var reader = XmlReader.Create(new StringReader(SerializationParameters), xmlReaderSettings))
{
reader.Read();
while (!reader.EOF)
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
if (reader.LocalName != "Parameter")
{
continue;
}
var name = reader.GetAttribute("Name");
var namespaceUri = reader.GetAttribute("Namespace") ?? string.Empty;
var value = reader.GetAttribute("Value");
var key = new XmlQualifiedName(name, namespaceUri);
if (TrySetSerializationParameter(serializerSettings, key, value) == false)
{
return(false);
}
reader.Skip();
break;
}
default:
reader.Skip();
break;
}
}
}
return(true);
}
catch (XmlException e)
{
LogXmlException(Severity.Error, e);
return(false);
}
}
