| public abstract WriteBase64 ( byte buffer, int index, int count ) : void | ||
| buffer | byte | |
| index | int | |
| count | int | |
| return | void | |
public void WriteXml( XmlWriter writer )
{
writer.WriteStartElement( XmlEncryptionConstants.Prefix, XmlEncryptionConstants.Elements.CipherData, XmlEncryptionConstants.Namespace );
writer.WriteStartElement( XmlEncryptionConstants.Prefix, XmlEncryptionConstants.Elements.CipherValue, XmlEncryptionConstants.Namespace );
if ( _iv != null )
writer.WriteBase64( _iv, 0, _iv.Length );
writer.WriteBase64( _cipherText, 0, _cipherText.Length );
writer.WriteEndElement(); // CipherValue
writer.WriteEndElement(); // CipherData
}
public virtual void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteStartElement("WriteBase64");
byte[] bits = System.Text.Encoding.UTF8.GetBytes("hello world");
writer.WriteBase64(bits, 0, bits.Length);
writer.WriteEndElement(); // WriteBase64
}
protected void WriteValue(string valueElt, ADValue value, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(valueElt, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(valueElt);
}
if (value.IsBinary && value.BinaryVal != null)
{
mXmlWriter.WriteAttributeString("xsi", "type", DsmlConstants.XsiUri,
DsmlConstants.AttrBinaryTypePrefixedValue);
mXmlWriter.WriteBase64(value.BinaryVal, 0, value.BinaryVal.Length);
}
else
{
//note that the WriteString method handles a null argument correctly
mXmlWriter.WriteString(value.StringVal);
}
mXmlWriter.WriteEndElement();
}
public void WriteModulusAsBase64(XmlWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
writer.WriteBase64(this.rsaParameters.Modulus, 0, this.rsaParameters.Modulus.Length);
}
private void ExportAdditionalFile(XmlWriter writer, ReleaseAdditionalFile additionalFile)
{
writer.WriteStartElement(Keys.AdditionalFile);
writer.WriteAttributeString(Keys.Type, additionalFile.Type.ToString());
writer.WriteAttributeString(Keys.Description, additionalFile.Description);
writer.WriteAttributeString(Keys.OriginalFilename, additionalFile.OriginalFilename);
writer.WriteBase64(additionalFile.File, 0, additionalFile.File.Length);
writer.WriteEndElement();
}
private static void WriteElementTo(PmlElement Element, System.Xml.XmlWriter Writer)
{
switch (Element.Type)
{
case PmlType.Binary:
Writer.WriteAttributeString("type", "binary");
byte[] Bytes = Element.ToByteArray();
Writer.WriteBase64(Bytes, 0, Bytes.Length);
break;
case PmlType.Collection:
Writer.WriteAttributeString("type", "collection");
foreach (PmlElement Child in (PmlCollection)Element)
{
Writer.WriteStartElement("item");
WriteElementTo(Child, Writer);
Writer.WriteEndElement();
}
break;
case PmlType.Dictionary:
Writer.WriteAttributeString("type", "dictionary");
foreach (KeyValuePair <string, PmlElement> Child in (PmlDictionary)Element)
{
Writer.WriteStartElement(Child.Key);
WriteElementTo(Child.Value, Writer);
Writer.WriteEndElement();
}
break;
case PmlType.Integer:
Writer.WriteAttributeString("type", "integer");
Writer.WriteString(Element.ToString());
break;
case PmlType.Null:
Writer.WriteAttributeString("type", "null");
break;
case PmlType.String:
Writer.WriteAttributeString("type", "string");
Writer.WriteString(Element.ToString());
break;
}
}
public void WriteXml(XmlWriter writer)
{
// TODO: Implement more robust serialization
Type type = GetType();
TypeAccessor accessor = ObjectHydrator.GetAccessor(type);
writer.WriteElementString("type", type.GetName());
IList<string> fieldsToNull = new List<string>();
foreach (PropertyInfo info in from info in type.FilterProperties<SalesforceReadonly>()
let ignoreAttribute = info.GetCustomAttribute<SalesforceIgnore>()
where ignoreAttribute == null || !ignoreAttribute.IfEmpty
select info)
{
object value = accessor[this, info.Name];
string salesforceName = info.GetName();
if (value == null)
{
fieldsToNull.Add(salesforceName);
continue;
}
var xmlValue = value is DateTime
? ((DateTime) value).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ") // Contributed by: Murillo.Mike - Salesforce requires UTC dates
: value.ToString();
//Added additional routine for when value is Byte[] ---bnewbold 22OCT2014
if ((value as byte[]) != null)
{
//When value is passed in a byte array, as when uploading a filestream file, we need to read the value in rather than cast it to a string.
byte[] byteArray = (byte[])value; //Cast value as byte array into temp variable
writer.WriteStartElement(info.GetName()); //Not using WriteElementsString so need to preface with the XML Tag
writer.WriteBase64(byteArray, 0, byteArray.Length); //Just use base64 XML Writer
writer.WriteEndElement(); //Close the xml tag
continue;
}
writer.WriteElementString(salesforceName, SalesforceNamespaces.SObject, xmlValue);
}
if (OperationType != CrudOperations.Insert)
{
foreach (string field in fieldsToNull)
writer.WriteElementString("fieldsToNull", SalesforceNamespaces.SObject, field);
}
}
public override void WriteToken(System.Xml.XmlWriter writer, System.IdentityModel.Tokens.SecurityToken token)
{
if (!(token is JsonWebSecurityToken))
{
base.WriteToken(writer, token);
}
Utility.VerifyNonNullArgument("writer", writer);
byte[] bytes = Base64UrlEncoder.TextEncoding.GetBytes(this.WriteTokenAsString(token));
writer.WriteStartElement("wsse", "BinarySecurityToken", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
if (token.Id != null)
{
writer.WriteAttributeString("wsu", "Id", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd", token.Id);
}
writer.WriteAttributeString("ValueType", null, "http://oauth.net/grant_type/jwt/1.0/bearer");
writer.WriteAttributeString("EncodingType", null, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary");
writer.WriteBase64(bytes, 0, bytes.Length);
writer.WriteEndElement();
}
/// <summary>
/// Replay all cached events to an XmlWriter.
/// </summary>
public void EventsToWriter(XmlWriter writer)
{
XmlEvent[] page;
int idxPage, idxEvent;
byte[] bytes;
char[] chars;
XmlRawWriter rawWriter;
// Special-case single text node at the top-level
if (this.singleText.Count != 0)
{
writer.WriteString(this.singleText.GetResult());
return;
}
rawWriter = writer as XmlRawWriter;
// Loop over set of pages
for (idxPage = 0; idxPage < this.pages.Count; idxPage++)
{
page = this.pages[idxPage];
// Loop over events in each page
for (idxEvent = 0; idxEvent < page.Length; idxEvent++)
{
switch (page[idxEvent].EventType)
{
case XmlEventType.Unknown:
// No more events
Debug.Assert(idxPage + 1 == this.pages.Count);
return;
case XmlEventType.DocType:
writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string)page[idxEvent].Object);
break;
case XmlEventType.StartElem:
writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.StartAttr:
writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.EndAttr:
writer.WriteEndAttribute();
break;
case XmlEventType.CData:
writer.WriteCData(page[idxEvent].String1);
break;
case XmlEventType.Comment:
writer.WriteComment(page[idxEvent].String1);
break;
case XmlEventType.PI:
writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2);
break;
case XmlEventType.Whitespace:
writer.WriteWhitespace(page[idxEvent].String1);
break;
case XmlEventType.String:
writer.WriteString(page[idxEvent].String1);
break;
case XmlEventType.Raw:
writer.WriteRaw(page[idxEvent].String1);
break;
case XmlEventType.EntRef:
writer.WriteEntityRef(page[idxEvent].String1);
break;
case XmlEventType.CharEnt:
writer.WriteCharEntity((char)page[idxEvent].Object);
break;
case XmlEventType.SurrCharEnt:
chars = (char[])page[idxEvent].Object;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case XmlEventType.Base64:
bytes = (byte[])page[idxEvent].Object;
writer.WriteBase64(bytes, 0, bytes.Length);
break;
case XmlEventType.BinHex:
bytes = (byte[])page[idxEvent].Object;
writer.WriteBinHex(bytes, 0, bytes.Length);
break;
case XmlEventType.XmlDecl1:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration((XmlStandalone)page[idxEvent].Object);
}
break;
case XmlEventType.XmlDecl2:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration(page[idxEvent].String1);
}
break;
case XmlEventType.StartContent:
if (rawWriter != null)
{
rawWriter.StartElementContent();
}
break;
case XmlEventType.EndElem:
if (rawWriter != null)
{
rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
}
else
{
writer.WriteEndElement();
}
break;
case XmlEventType.FullEndElem:
if (rawWriter != null)
{
rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
}
else
{
writer.WriteFullEndElement();
}
break;
case XmlEventType.Nmsp:
if (rawWriter != null)
{
rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2);
}
else
{
writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2);
}
break;
case XmlEventType.EndBase64:
if (rawWriter != null)
{
rawWriter.WriteEndBase64();
}
break;
case XmlEventType.Close:
writer.Close();
break;
case XmlEventType.Flush:
writer.Flush();
break;
case XmlEventType.Dispose:
((IDisposable)writer).Dispose();
break;
default:
Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType);
break;
}
}
}
Debug.Assert(false, "Unknown event should be added to end of event sequence.");
}
/// <summary>
/// Write binary chunk data according to encoding type to xml script.
/// </summary>
/// <param name="writer">Xml writer.</param>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <param name="chunkData">Chunk data.</param>
private static void WriteBinaryData(XmlWriter writer, ScriptAcousticChunkEncoding chunkEncoding,
Collection<float> chunkData)
{
Debug.Assert(writer != null);
Debug.Assert(chunkEncoding == ScriptAcousticChunkEncoding.Base64Binary ||
chunkEncoding == ScriptAcousticChunkEncoding.HexBinary);
int bufSize = chunkData.Count * sizeof(float);
byte[] bytes = new byte[bufSize];
int bytesIndex = 0;
for (int i = 0; i < chunkData.Count; i++)
{
byte[] floatBytes = BitConverter.GetBytes(chunkData[i]);
for (int j = 0; j < sizeof(float); j++)
{
bytes[bytesIndex] = floatBytes[j];
bytesIndex ++;
}
}
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Base64Binary:
writer.WriteBase64(bytes, 0, bufSize);
break;
case ScriptAcousticChunkEncoding.HexBinary:
writer.WriteBinHex(bytes, 0, bufSize);
break;
}
}
public void EventsToWriter(XmlWriter writer)
{
if (this.singleText.Count != 0)
{
writer.WriteString(this.singleText.GetResult());
}
else
{
XmlRawWriter writer2 = writer as XmlRawWriter;
for (int i = 0; i < this.pages.Count; i++)
{
XmlEvent[] eventArray = this.pages[i];
for (int j = 0; j < eventArray.Length; j++)
{
byte[] buffer;
switch (eventArray[j].EventType)
{
case XmlEventType.Unknown:
return;
case XmlEventType.DocType:
{
writer.WriteDocType(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3, (string)eventArray[j].Object);
continue;
}
case XmlEventType.StartElem:
{
writer.WriteStartElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.StartAttr:
{
writer.WriteStartAttribute(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.EndAttr:
{
writer.WriteEndAttribute();
continue;
}
case XmlEventType.CData:
{
writer.WriteCData(eventArray[j].String1);
continue;
}
case XmlEventType.Comment:
{
writer.WriteComment(eventArray[j].String1);
continue;
}
case XmlEventType.PI:
{
writer.WriteProcessingInstruction(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.Whitespace:
{
writer.WriteWhitespace(eventArray[j].String1);
continue;
}
case XmlEventType.String:
{
writer.WriteString(eventArray[j].String1);
continue;
}
case XmlEventType.Raw:
{
writer.WriteRaw(eventArray[j].String1);
continue;
}
case XmlEventType.EntRef:
{
writer.WriteEntityRef(eventArray[j].String1);
continue;
}
case XmlEventType.CharEnt:
{
writer.WriteCharEntity((char)eventArray[j].Object);
continue;
}
case XmlEventType.SurrCharEnt:
{
char[] chArray = (char[])eventArray[j].Object;
writer.WriteSurrogateCharEntity(chArray[0], chArray[1]);
continue;
}
case XmlEventType.Base64:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBase64(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.BinHex:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBinHex(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.XmlDecl1:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration((XmlStandalone)eventArray[j].Object);
}
continue;
}
case XmlEventType.XmlDecl2:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration(eventArray[j].String1);
}
continue;
}
case XmlEventType.StartContent:
{
if (writer2 != null)
{
writer2.StartElementContent();
}
continue;
}
case XmlEventType.EndElem:
{
if (writer2 == null)
{
break;
}
writer2.WriteEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.FullEndElem:
{
if (writer2 == null)
{
goto Label_0367;
}
writer2.WriteFullEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.Nmsp:
{
if (writer2 == null)
{
goto Label_0394;
}
writer2.WriteNamespaceDeclaration(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.EndBase64:
{
if (writer2 != null)
{
writer2.WriteEndBase64();
}
continue;
}
case XmlEventType.Close:
{
writer.Close();
continue;
}
case XmlEventType.Flush:
{
writer.Flush();
continue;
}
case XmlEventType.Dispose:
{
writer.Dispose();
continue;
}
default:
{
continue;
}
}
writer.WriteEndElement();
continue;
Label_0367:
writer.WriteFullEndElement();
continue;
Label_0394:
writer.WriteAttributeString("xmlns", eventArray[j].String1, "http://www.w3.org/2000/xmlns/", eventArray[j].String2);
}
}
}
}
internal static void WriteArrayBase64(XmlWriter writer, byte[] inData, int start, int count)
{
if ((inData != null) && (count != 0))
{
writer.WriteBase64(inData, start, count);
}
}
protected void WriteValue(string valueElt, ADValue value, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(valueElt, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(valueElt);
}
if (value.IsBinary && (value.BinaryVal != null))
{
mXmlWriter.WriteAttributeString("xsi", "type", "http://www.w3.org/2001/XMLSchema-instance", "xsd:base64Binary");
mXmlWriter.WriteBase64(value.BinaryVal, 0, value.BinaryVal.Length);
}
else
{
mXmlWriter.WriteString(value.StringVal);
}
mXmlWriter.WriteEndElement();
}
internal static void WriteArrayBase64(XmlWriter writer, byte[] inData, int start, int count)
{
if (inData == null || count == 0)
{
return;
}
writer.WriteBase64(inData, start, count);
}
public static void WriteImageElement(XmlWriter writer, string nodeName, bool includeImages, string imageUrl)
{
writer.WriteStartElement(nodeName);
if (includeImages)
{
byte[] buffer = ConvertToBytes(imageUrl);
writer.WriteBase64(buffer, 0, buffer.Length);
}
else
{
writer.WriteString(imageUrl);
}
writer.WriteEndElement();
}
public void WriteTo(XmlWriter writer)
{
writer.WriteStartElement(XmlEncryptionStrings.Prefix, XmlEncryptionStrings.CipherData, XmlEncryptionStrings.Namespace);
writer.WriteStartElement(XmlEncryptionStrings.Prefix, XmlEncryptionStrings.CipherValue, XmlEncryptionStrings.Namespace);
if (this.m_iv != null)
writer.WriteBase64(this.m_iv, 0, this.m_iv.Length);
writer.WriteBase64(this.m_cipherText, 0, this.m_cipherText.Length);
writer.WriteEndElement(); // CipherValue
writer.WriteEndElement(); // CipherData
}
public override void WriteBase64(byte[] buffer, int index, int count)
{
_writer.WriteBase64(buffer, index, count);
}
/// <summary>
/// Writes the X509SecurityToken to the given XmlWriter.
/// </summary>
/// <param name="writer">XmlWriter to write the token into.</param>
/// <param name="token">The SecurityToken of type X509SecurityToken to be written.</param>
/// <exception cref="ArgumentNullException">The parameter 'writer' or 'token' is null.</exception>
/// <exception cref="ArgumentException">The token is not of type X509SecurityToken.</exception>
public override void WriteToken(XmlWriter writer, SecurityToken token)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (token == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("token");
}
X509SecurityToken x509Token = token as X509SecurityToken;
if (x509Token == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("token", SR.GetString(SR.ID0018, typeof(X509SecurityToken)));
}
writer.WriteStartElement(WSSecurity10Constants.Elements.BinarySecurityToken, WSSecurity10Constants.Namespace);
if (!String.IsNullOrEmpty(x509Token.Id))
{
writer.WriteAttributeString(WSSecurityUtilityConstants.Attributes.Id, WSSecurityUtilityConstants.Namespace, x509Token.Id);
}
writer.WriteAttributeString(WSSecurity10Constants.Attributes.ValueType, null, WSSecurity10Constants.X509TokenType);
writer.WriteAttributeString(WSSecurity10Constants.Attributes.EncodingType, WSSecurity10Constants.Base64EncodingType);
byte[] rawData = x509Token.Certificate.GetRawCertData();
writer.WriteBase64(rawData, 0, rawData.Length);
writer.WriteEndElement();
}
private void SerializeImage(XmlWriter writer, Image image)
{
MemoryStream stream = new MemoryStream();
try
{
image.Save(stream, ImageFormat.Png);
}
catch
{
image.Save(stream, ImageFormat.Bmp);
}
writer.WriteStartElement("Image");
writer.WriteStartElement("Data");
byte[] buffer = stream.ToArray();
writer.WriteBase64(buffer, 0, buffer.Length);
writer.WriteEndElement();
writer.WriteEndElement();
}
/// <remarks>Serialize the object to the output stream.</remarks>
/// <param name="output">An <c>XmlTextWriter</c> stream to write data to.</param>
/// <param name="obj">An <c>Object</c> to serialize.</param>
public void SerializeObject(XmlWriter output, Object obj)
{
if (obj == null)
return;
if (obj is byte[])
{
byte[] ba = (byte[])obj;
output.WriteStartElement(BASE64);
output.WriteBase64(ba,0,ba.Length);
output.WriteEndElement();
}
else if (obj is String)
{
output.WriteElementString(STRING,obj.ToString());
}
else if (obj is Int32)
{
output.WriteElementString(INT,obj.ToString());
}
else if (obj is DateTime)
{
output.WriteElementString(DATETIME,((DateTime)obj).ToString(ISO_DATETIME));
}
else if (obj is Double)
{
output.WriteElementString(DOUBLE,obj.ToString());
}
else if (obj is Boolean)
{
output.WriteElementString(BOOLEAN, ((((Boolean)obj) == true)?"1":"0"));
}
else if (obj is IList)
{
output.WriteStartElement(ARRAY);
output.WriteStartElement(DATA);
if (((ArrayList)obj).Count > 0)
{
foreach (Object member in ((IList)obj))
{
output.WriteStartElement(VALUE);
SerializeObject(output,member);
output.WriteEndElement();
}
}
output.WriteEndElement();
output.WriteEndElement();
}
else if (obj is IDictionary)
{
IDictionary h = (IDictionary)obj;
output.WriteStartElement(STRUCT);
foreach (String key in h.Keys)
{
output.WriteStartElement(MEMBER);
output.WriteElementString(NAME,key);
output.WriteStartElement(VALUE);
SerializeObject(output,h[key]);
output.WriteEndElement();
output.WriteEndElement();
}
output.WriteEndElement();
}
}
/// <summary>
///
/// </summary>
/// <param name="xtw"></param>
/// <param name="o"></param>
/// <param name="mappingAction"></param>
/// <param name="nestedObjs"></param>
public void Serialize(
XmlWriter xtw,
Object o,
NullMappingAction mappingAction,
List<object> nestedObjs)
{
if (nestedObjs.Contains(o))
throw new XmlRpcUnsupportedTypeException(nestedObjs[0].GetType(),
"Cannot serialize recursive data structure");
nestedObjs.Add(o);
try
{
xtw.WriteStartElement("", "value", "");
XmlRpcType xType = XmlRpcTypeInfo.GetXmlRpcType(o);
if (xType == XmlRpcType.tArray)
{
xtw.WriteStartElement("", "array", "");
xtw.WriteStartElement("", "data", "");
Array a = (Array)o;
foreach (Object aobj in a)
{
//if (aobj == null)
// throw new XmlRpcMappingSerializeException(String.Format(
// "Items in array cannot be null ({0}[]).",
//o.GetType().GetElementType()));
Serialize(xtw, aobj, mappingAction, nestedObjs);
}
WriteFullEndElement(xtw);
WriteFullEndElement(xtw);
}
else if (xType == XmlRpcType.tMultiDimArray)
{
Array mda = (Array)o;
int[] indices = new int[mda.Rank];
BuildArrayXml(xtw, mda, 0, indices, mappingAction, nestedObjs);
}
else if (xType == XmlRpcType.tBase64)
{
byte[] buf = (byte[])o;
xtw.WriteStartElement("", "base64", "");
xtw.WriteBase64(buf, 0, buf.Length);
WriteFullEndElement(xtw);
}
else if (xType == XmlRpcType.tBoolean)
{
bool boolVal = (bool)o;
if (boolVal)
WriteFullElementString(xtw, "boolean", "1");
else
WriteFullElementString(xtw, "boolean", "0");
}
else if (xType == XmlRpcType.tDateTime)
{
DateTime dt = (DateTime)o;
string sdt = dt.ToString("yyyyMMdd'T'HH':'mm':'ss",
DateTimeFormatInfo.InvariantInfo);
WriteFullElementString(xtw, "dateTime.iso8601", sdt);
}
else if (xType == XmlRpcType.tDouble)
{
double doubleVal = (double)o;
WriteFullElementString(xtw, "double", doubleVal.ToString(null,
CultureInfo.InvariantCulture));
}
else if (xType == XmlRpcType.tHashtable)
{
xtw.WriteStartElement("", "struct", "");
XmlRpcStruct xrs = o as XmlRpcStruct;
foreach (object obj in xrs.Keys)
{
string skey = obj as string;
xtw.WriteStartElement("", "member", "");
WriteFullElementString(xtw, "name", skey);
Serialize(xtw, xrs[skey], mappingAction, nestedObjs);
WriteFullEndElement(xtw);
}
WriteFullEndElement(xtw);
}
else if (xType == XmlRpcType.tInt32)
{
if (o.GetType().IsEnum)
o = Convert.ToInt32(o);
if (UseIntTag)
WriteFullElementString(xtw, "int", o.ToString());
else
WriteFullElementString(xtw, "i4", o.ToString());
}
else if (xType == XmlRpcType.tInt64)
{
if (o.GetType().IsEnum)
o = Convert.ToInt64(o);
WriteFullElementString(xtw, "i8", o.ToString());
}
else if (xType == XmlRpcType.tString)
{
if (UseStringTag)
{
WriteFullElementString(xtw, "string", (string)o);
}
else
xtw.WriteString((string)o);
}
else if (xType == XmlRpcType.tStruct)
{
NullMappingAction structAction
= StructMappingAction(o.GetType(), mappingAction);
xtw.WriteStartElement("", "struct", "");
MemberInfo[] mis = o.GetType().GetMembers();
foreach (MemberInfo mi in mis)
{
if (Attribute.IsDefined(mi, typeof(NonSerializedAttribute)))
continue;
if (mi.MemberType == MemberTypes.Field)
{
FieldInfo fi = (FieldInfo)mi;
string member = fi.Name;
Attribute attrchk = Attribute.GetCustomAttribute(fi,
typeof(XmlRpcMemberAttribute));
if (attrchk != null && attrchk is XmlRpcMemberAttribute)
{
string mmbr = ((XmlRpcMemberAttribute)attrchk).Member;
if (mmbr != "")
member = mmbr;
}
if (fi.GetValue(o) == null)
{
NullMappingAction memberAction = MemberNullMappingAction(o.GetType(),
fi.Name, structAction);
if (memberAction == NullMappingAction.Ignore)
continue;
else if (memberAction == NullMappingAction.Error)
throw new XmlRpcMappingSerializeException(@"Member """ + member +
@""" of struct """ + o.GetType().Name + @""" cannot be null.");
}
xtw.WriteStartElement("", "member", "");
WriteFullElementString(xtw, "name", member);
Serialize(xtw, fi.GetValue(o), mappingAction, nestedObjs);
WriteFullEndElement(xtw);
}
else if (mi.MemberType == MemberTypes.Property)
{
PropertyInfo pi = (PropertyInfo)mi;
string member = pi.Name;
Attribute attrchk = Attribute.GetCustomAttribute(pi,
typeof(XmlRpcMemberAttribute));
if (attrchk != null && attrchk is XmlRpcMemberAttribute)
{
string mmbr = ((XmlRpcMemberAttribute)attrchk).Member;
if (mmbr != "")
member = mmbr;
}
if (pi.GetValue(o, null) == null)
{
NullMappingAction memberAction = MemberNullMappingAction(o.GetType(),
pi.Name, structAction);
if (memberAction == NullMappingAction.Ignore)
continue;
else if (memberAction == NullMappingAction.Error)
throw new XmlRpcMappingSerializeException(@"Member """ + member +
@""" of struct """ + o.GetType().Name + @""" cannot be null.");
}
xtw.WriteStartElement("", "member", "");
WriteFullElementString(xtw, "name", member);
Serialize(xtw, pi.GetValue(o, null), mappingAction, nestedObjs);
WriteFullEndElement(xtw);
}
}
WriteFullEndElement(xtw);
}
else if (xType == XmlRpcType.tVoid)
WriteFullElementString(xtw, "string", "");
else if (xType == XmlRpcType.tNil)
{
xtw.WriteStartElement("nil");
WriteFullEndElement(xtw);
}
else
throw new XmlRpcUnsupportedTypeException(o.GetType());
WriteFullEndElement(xtw);
}
catch (System.NullReferenceException)
{
throw new XmlRpcNullReferenceException("Attempt to serialize data "
+ "containing null reference");
}
finally
{
nestedObjs.RemoveAt(nestedObjs.Count - 1);
}
}
/// <summary>
/// Writes the <see cref="JwtSecurityToken"/> wrapped in a WS-Security BinarySecurityToken using the <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer"><see cref="XmlWriter"/> used to write token.</param>
/// <param name="token">The <see cref="JwtSecurityToken"/> that will be written.</param>
/// <exception cref="ArgumentNullException">'writer' is null.</exception>
/// <exception cref="ArgumentNullException">'token' is null.</exception>
/// <exception cref="ArgumentException">'token' is not a not <see cref="JwtSecurityToken"/>.</exception>
/// <remarks>The <see cref="JwtSecurityToken"/> current contents are encoded. If <see cref="JwtSecurityToken.SigningCredentials"/> is not null, the encoding will contain a signature.</remarks>
public override void WriteToken(XmlWriter writer, SecurityToken token)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (token == null)
{
throw new ArgumentNullException("token");
}
if (!(token is JwtSecurityToken))
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, ErrorMessages.IDX10226, GetType(), typeof(JwtSecurityToken), token.GetType()));
}
byte[] rawData = Encoding.UTF8.GetBytes(this.WriteToken(token));
writer.WriteStartElement(WSSecurityConstantsInternal.Prefix, WSSecurityConstantsInternal.Elements.BinarySecurityToken, WSSecurityConstantsInternal.Namespace);
if (token.Id != null)
{
writer.WriteAttributeString(WSSecurityConstantsInternal.Prefix, WSSecurityUtilityConstantsInternal.Attributes.Id, WSSecurityConstantsInternal.Namespace, token.Id);
}
writer.WriteAttributeString(WSSecurityConstantsInternal.Attributes.ValueType, null, JwtConstants.TokenTypeAlt);
writer.WriteAttributeString(WSSecurityConstantsInternal.Attributes.EncodingType, null, WSSecurityConstantsInternal.Base64EncodingType);
writer.WriteBase64(rawData, 0, rawData.Length);
writer.WriteEndElement();
}
/// <summary>
/// Serializes an RSA security token to XML.
/// </summary>
/// <param name="writer">The XML writer.</param>
/// <param name="token">An RSA security token.</param>
/// <exception cref="ArgumentNullException">The input argument 'writer' is null.</exception>
/// <exception cref="InvalidOperationException">The input argument 'token' is either null or not of type
/// <see cref="RsaSecurityToken"/>.</exception>
public override void WriteToken(XmlWriter writer, SecurityToken token)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (token == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("token");
}
RsaSecurityToken rsaToken = token as RsaSecurityToken;
if (rsaToken == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("token", SR.GetString(SR.ID0018, typeof(RsaSecurityToken)));
}
RSAParameters rsaParams = rsaToken.Rsa.ExportParameters(false);
writer.WriteStartElement(XmlSignatureConstants.Elements.KeyInfo, XmlSignatureConstants.Namespace);
writer.WriteStartElement(XmlSignatureConstants.Elements.KeyValue, XmlSignatureConstants.Namespace);
//
// RSA.ToXmlString shouldn't be used here because it doesn't write namespaces. The modulus and exponent are written manually.
//
writer.WriteStartElement(XmlSignatureConstants.Elements.RsaKeyValue, XmlSignatureConstants.Namespace);
writer.WriteStartElement(XmlSignatureConstants.Elements.Modulus, XmlSignatureConstants.Namespace);
byte[] modulus = rsaParams.Modulus;
writer.WriteBase64(modulus, 0, modulus.Length);
writer.WriteEndElement(); // </modulus>
writer.WriteStartElement(XmlSignatureConstants.Elements.Exponent, XmlSignatureConstants.Namespace);
byte[] exponent = rsaParams.Exponent;
writer.WriteBase64(exponent, 0, exponent.Length);
writer.WriteEndElement(); // </exponent>
writer.WriteEndElement(); // </RsaKeyValue>
writer.WriteEndElement(); // </KeyValue>
writer.WriteEndElement(); // </KeyInfo>
}
public override void WriteBase64(byte [] buffer, int index, int count)
{
writer.WriteBase64(buffer, index, count);
state = WriteState.Content;
}
/// <summary>
/// Implementation of WriteXml for serialization
/// </summary>
/// <param name="writer">XmlWriter that can be used to serialize the object</param>
public void WriteXml(XmlWriter writer)
{
if (this.Email != null)
{
writer.WriteStartElement("MailMessage");
writer.WriteAttributeString("Priority", Convert.ToInt16(this.Email.Priority).ToString());
writer.WriteAttributeString("IsBodyHtml", this.Email.IsBodyHtml.ToString());
// From
writer.WriteStartElement("From");
if (!string.IsNullOrEmpty(this.Email.From.DisplayName))
writer.WriteAttributeString("DisplayName", this.Email.From.DisplayName);
writer.WriteRaw(this.Email.From.Address);
writer.WriteEndElement();
// To
writer.WriteStartElement("To");
writer.WriteStartElement("Addresses");
foreach (MailAddress address in this.Email.To)
{
writer.WriteStartElement("Address");
if (!string.IsNullOrEmpty(address.DisplayName))
writer.WriteAttributeString("DisplayName", address.DisplayName);
writer.WriteRaw(address.Address);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
// CC
if (this.Email.CC.Count > 0)
{
writer.WriteStartElement("CC");
writer.WriteStartElement("Addresses");
foreach (MailAddress address in this.Email.CC)
{
writer.WriteStartElement("Address");
if (!string.IsNullOrEmpty(address.DisplayName))
writer.WriteAttributeString("DisplayName", address.DisplayName);
writer.WriteRaw(address.Address);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
// Bcc
if (this.Email.Bcc.Count > 0)
{
writer.WriteStartElement("Bcc");
writer.WriteStartElement("Addresses");
foreach (MailAddress address in this.Email.Bcc)
{
writer.WriteStartElement("Address");
if (!string.IsNullOrEmpty(address.DisplayName))
writer.WriteAttributeString("DisplayName", address.DisplayName);
writer.WriteRaw(address.Address);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
// Subject
writer.WriteStartElement("Subject");
writer.WriteRaw(this.Email.Subject);
writer.WriteEndElement();
// Body
writer.WriteStartElement("Body");
writer.WriteCData(this.Email.Body);
writer.WriteEndElement();
// ReplyTo
if (this.Email.ReplyTo != null)
{
writer.WriteStartElement("ReplyTo");
if (!string.IsNullOrEmpty(this.Email.ReplyTo.DisplayName))
writer.WriteAttributeString("DisplayName", this.Email.ReplyTo.DisplayName);
writer.WriteRaw(this.Email.ReplyTo.Address);
writer.WriteEndElement();
}
// Sender
if (this.Email.Sender != null)
{
writer.WriteStartElement("Sender");
if (!string.IsNullOrEmpty(this.Email.Sender.DisplayName))
writer.WriteAttributeString("DisplayName", this.Email.Sender.DisplayName);
writer.WriteRaw(this.Email.Sender.Address);
writer.WriteEndElement();
}
// Attachments
if (this.Email.Attachments.Count > 0)
{
writer.WriteStartElement("Attachments");
foreach (Attachment attachment in this.Email.Attachments)
{
writer.WriteStartElement("Attachment");
if (!string.IsNullOrEmpty(attachment.Name))
writer.WriteAttributeString("ContentType", attachment.ContentType.ToString());
using (BinaryReader reader = new BinaryReader(attachment.ContentStream))
{
byte[] data = reader.ReadBytes((int)attachment.ContentStream.Length);
writer.WriteBase64(data, 0, data.Length);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
private static void WriteItem(XmlWriter writer, IPropertyListItem item)
{
switch (item.Type)
{
case PropertyListItemTypes.Dictionary:
writer.WriteStartElement("dict");
foreach (KeyValuePair<string, IPropertyListItem> childItem in item.DictionaryItems)
{
writer.WriteStartElement("key");
writer.WriteString(childItem.Key);
writer.WriteEndElement();
WriteItem(writer, childItem.Value);
}
writer.WriteEndElement();
break;
case PropertyListItemTypes.Array:
writer.WriteStartElement("array");
foreach (IPropertyListItem childItem in item.ArrayItems)
WriteItem(writer, childItem);
writer.WriteEndElement();
break;
case PropertyListItemTypes.Binary:
writer.WriteStartElement("data");
writer.WriteBase64(item.BinaryValue, 0, item.BinaryValue.Length);
writer.WriteEndElement();
break;
case PropertyListItemTypes.Boolean:
if (item.BooleanValue)
writer.WriteStartElement("true");
else
writer.WriteStartElement("false");
writer.WriteEndElement();
break;
case PropertyListItemTypes.DateTime:
writer.WriteStartElement("date");
writer.WriteString(item.DateTimeValue.ToString("s", CultureInfo.InvariantCulture));
writer.WriteEndElement();
break;
case PropertyListItemTypes.String:
writer.WriteStartElement("string");
writer.WriteString(item.StringValue);
writer.WriteEndElement();
break;
case PropertyListItemTypes.FloatingNumber:
writer.WriteStartElement("real");
writer.WriteString(item.StringValue);
writer.WriteEndElement();
break;
case PropertyListItemTypes.IntegerNumber:
writer.WriteStartElement("integer");
writer.WriteString(item.StringValue);
writer.WriteEndElement();
break;
default:
throw new InvalidOperationException("Serialization action not defined for given item type (" + item.Type + ")!");
}
}
private void ExportImage(XmlWriter writer, Image image)
{
writer.WriteStartElement(Keys.Image);
writer.WriteAttributeString(Keys.Type, image.Type.ToString());
if (image.MimeType == "application/unknown")
{
image.MimeType = MimeHelper.GetMimeTypeForExtension(image.Extension);
}
writer.WriteAttributeString(Keys.MimeType, image.MimeType);
writer.WriteAttributeString(Keys.Extension, image.Extension);
writer.WriteAttributeString(Keys.Description, image.Description);
writer.WriteAttributeString(Keys.IsMain, image.IsMain.ToString());
byte[] imageBytes = this.collectionManager.ImageHandler.LoadImage(image);
writer.WriteBase64(imageBytes, 0, imageBytes.Length);
writer.WriteEndElement();
}
private void InvokeMethod(XmlWriter w, string methodName)
{
byte[] buffer = new byte[10];
switch (methodName)
{
case "WriteStartDocument":
w.WriteStartDocument();
break;
case "WriteStartElement":
w.WriteStartElement("root");
break;
case "WriteEndElement":
w.WriteEndElement();
break;
case "WriteStartAttribute":
w.WriteStartAttribute("attr");
break;
case "WriteEndAttribute":
w.WriteEndAttribute();
break;
case "WriteCData":
w.WriteCData("test");
break;
case "WriteComment":
w.WriteComment("test");
break;
case "WritePI":
w.WriteProcessingInstruction("name", "test");
break;
case "WriteEntityRef":
w.WriteEntityRef("e");
break;
case "WriteCharEntity":
w.WriteCharEntity('c');
break;
case "WriteSurrogateCharEntity":
w.WriteSurrogateCharEntity('\uDC00', '\uDBFF');
break;
case "WriteWhitespace":
w.WriteWhitespace(" ");
break;
case "WriteString":
w.WriteString("foo");
break;
case "WriteChars":
char[] charArray = new char[] { 'a', 'b', 'c', 'd' };
w.WriteChars(charArray, 0, 3);
break;
case "WriteRaw":
w.WriteRaw("<foo>bar</foo>");
break;
case "WriteBase64":
w.WriteBase64(buffer, 0, 9);
break;
case "WriteBinHex":
w.WriteBinHex(buffer, 0, 9);
break;
case "LookupPrefix":
string str = w.LookupPrefix("foo");
break;
case "WriteNmToken":
w.WriteNmToken("foo");
break;
case "WriteName":
w.WriteName("foo");
break;
case "WriteQualifiedName":
w.WriteQualifiedName("foo", "bar");
break;
case "WriteValue":
w.WriteValue(Int32.MaxValue);
break;
case "WriteAttributes":
XmlReader xr1 = ReaderHelper.Create(new StringReader("<root attr='test'/>"));
xr1.Read();
w.WriteAttributes(xr1, false);
break;
case "WriteNodeReader":
XmlReader xr2 = ReaderHelper.Create(new StringReader("<root/>"));
xr2.Read();
w.WriteNode(xr2, false);
break;
case "Flush":
w.Flush();
break;
default:
CError.Equals(false, "Unexpected param in testcase: {0}", methodName);
break;
}
}
public static void WriteBinarySecretSecurityToken(XmlWriter writer, BinarySecretSecurityToken token, WSTrustConstantsAdapter trustConstants)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (token == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("token");
}
if (trustConstants == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("trustConstants");
}
byte[] keyBytes = token.GetKeyBytes();
writer.WriteStartElement(trustConstants.Elements.BinarySecret, trustConstants.NamespaceURI);
writer.WriteBase64(keyBytes, 0, keyBytes.Length);
writer.WriteEndElement();
}
private void WriteContent(XmlWriter writer)
{
using (BinaryReader br = new BinaryReader(stream))
{
byte[] buffer = new byte[BufferSize];
int readBytes = 0;
while ((readBytes = br.Read(buffer, 0, BufferSize)) != 0)
{
writer.WriteBase64(buffer, 0, readBytes);
}
}
}
private static void WriteCompressedBody(XmlWriter xmlWriter, byte[] compressedData)
{
xmlWriter.WriteStartElement(WSCompressionStrings.CompressedBody,
WSCompressionStrings.NamespaceUri);
xmlWriter.WriteBase64(compressedData, 0, compressedData.Length);
xmlWriter.WriteEndElement();
}
private void SeedMapToXml(XmlWriter w)
{
w.WriteStartElement("seedMap");
w.WriteAttributeString("width", SeedMapWidth.ToString());
w.WriteAttributeString("height", SeedMapHeight.ToString());
w.WriteAttributeString("mapFormat", "base64");
w.WriteAttributeString("bitsPerSample", bitsPerSample.ToString());
int bytesPerSample = bitsPerSample >> 3;
float multiplier = (float)Math.Pow(256d, bytesPerSample) - 1f;
// generate byte array for base64 encoding
byte [] byteMap = new byte[bytesPerSample * SeedMapWidth * SeedMapHeight];
for ( int i = 0; i < ( SeedMapWidth * SeedMapHeight ); i++ ) {
int byteOffset = i * bytesPerSample;
int value = (int)Math.Round(SeedMap[i] * multiplier);
for (int j=0; j<bytesPerSample; j++) {
byteMap[byteOffset + j] = (byte)(value & 0xff);
value = value >> 8;
}
}
w.WriteBase64(byteMap, 0, bytesPerSample * SeedMapWidth * SeedMapHeight);
w.WriteEndElement();
return;
}
/// <summary>
/// Serialize a SecurityKeyIdentifierClause to the given XmlWriter.
/// </summary>
/// <param name="writer">XmlWriter to which the SecurityKeyIdentifierClause is serialized.</param>
/// <param name="securityKeyIdentifierClause">SecurityKeyIdentifierClause to serialize.</param>
/// <exception cref="ArgumentNullException">The input parameter 'reader' or 'securityKeyIdentifierClause' is null.</exception>
/// <exception cref="ArgumentException">The parameter 'securityKeyIdentifierClause' is not a supported clause type.</exception>
public override void WriteKeyIdentifierClause(XmlWriter writer, SecurityKeyIdentifierClause securityKeyIdentifierClause)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (securityKeyIdentifierClause == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("securityKeyIdentifierClause");
}
X509IssuerSerialKeyIdentifierClause issuerSerialClause = securityKeyIdentifierClause as X509IssuerSerialKeyIdentifierClause;
if (issuerSerialClause != null)
{
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Data, XmlSignatureConstants.Namespace);
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509IssuerSerial, XmlSignatureConstants.Namespace);
writer.WriteElementString(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509IssuerName, XmlSignatureConstants.Namespace, issuerSerialClause.IssuerName);
writer.WriteElementString(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509SerialNumber, XmlSignatureConstants.Namespace, issuerSerialClause.IssuerSerialNumber);
writer.WriteEndElement();
writer.WriteEndElement();
return;
}
X509SubjectKeyIdentifierClause skiClause = securityKeyIdentifierClause as X509SubjectKeyIdentifierClause;
if (skiClause != null)
{
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Data, XmlSignatureConstants.Namespace);
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509SKI, XmlSignatureConstants.Namespace);
byte[] ski = skiClause.GetX509SubjectKeyIdentifier();
writer.WriteBase64(ski, 0, ski.Length);
writer.WriteEndElement();
writer.WriteEndElement();
return;
}
#if INCLUDE_CERT_CHAIN
X509ChainRawDataKeyIdentifierClause x509ChainDataClause = securityKeyIdentifierClause as X509ChainRawDataKeyIdentifierClause;
if ( x509ChainDataClause != null )
{
writer.WriteStartElement( XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Data, XmlSignatureConstants.Namespace );
for( int i = 0; i < x509ChainDataClause.CertificateCount; i++ )
{
writer.WriteStartElement( XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Certificate, XmlSignatureConstants.Namespace );
byte[] rawData = x509ChainDataClause.GetX509RawData( i );
writer.WriteBase64( rawData, 0, rawData.Length );
writer.WriteEndElement();
}
writer.WriteEndElement();
return;
}
#endif
X509RawDataKeyIdentifierClause rawDataClause = securityKeyIdentifierClause as X509RawDataKeyIdentifierClause;
if (rawDataClause != null)
{
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Data, XmlSignatureConstants.Namespace);
writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Certificate, XmlSignatureConstants.Namespace);
byte[] rawData = rawDataClause.GetX509RawData();
writer.WriteBase64(rawData, 0, rawData.Length);
writer.WriteEndElement();
writer.WriteEndElement();
return;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("securityKeyIdentifierClause", SR.GetString(SR.ID4259, securityKeyIdentifierClause.GetType()));
}
private void WriteRow(Resultset rs, Row row, XmlWriter w)
{
w.WriteStartElement("row");
foreach (RowType.TypeInfo ti in rs.RowType.Fields)
{
w.WriteStartElement(XmlConvert.EncodeLocalName(ti.Name));
object value = row.GetValue(ti.Ordinal);
if (value != DBNull.Value && value != null)
{
if (value is XmlNode)
{
XmlNode node = (XmlNode)value;
node.WriteTo(w);
}
else if (value is XPathItem)
{
XPathNavigator nav = value as XPathNavigator;
if (nav != null)
nav.WriteSubtree(w);
else
{
XPathItem item = (XPathItem)value;
w.WriteString(item.Value);
}
}
else if (value is XmlNodeList)
{
XmlNodeList nodeList = (XmlNodeList)value;
foreach (XmlNode node in nodeList)
node.WriteTo(w);
}
else if (value is Array)
{
Array array = (Array)value;
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
formatter.Serialize(ms, array);
w.WriteBase64(ms.GetBuffer(), 0, (int)ms.Length);
ms.Close();
}
else if (value is Resultset)
{
Resultset nested_rs = (Resultset)value;
WriteNestedResultset(nested_rs, w);
}
else
w.WriteValue(XmlDataAccessor.Serialize(value));
}
w.WriteEndElement();
}
w.WriteEndElement();
}
public override void WriteBase64(byte[] buffer, int index, int count)
{
CheckAsync();
coreWriter.WriteBase64(buffer, index, count);
}
// XML.
protected override void ExportXml (XmlWriter xw) {
xw.WriteBase64 (value, 0, value.Length);
}
public override void WriteBase64(byte [] bytes, int start, int length)
{
CheckState();
w.WriteBase64(bytes, start, length);
}
/// <summary>
/// Replay all cached events to an XmlWriter.
/// </summary>
public void EventsToWriter(XmlWriter writer) {
XmlEvent[] page;
int idxPage, idxEvent;
byte[] bytes;
char[] chars;
XmlRawWriter rawWriter;
// Special-case single text node at the top-level
if (this.singleText.Count != 0) {
writer.WriteString(this.singleText.GetResult());
return;
}
rawWriter = writer as XmlRawWriter;
// Loop over set of pages
for (idxPage = 0; idxPage < this.pages.Count; idxPage++) {
page = this.pages[idxPage];
// Loop over events in each page
for (idxEvent = 0; idxEvent < page.Length; idxEvent++) {
switch (page[idxEvent].EventType) {
case XmlEventType.Unknown:
// No more events
Debug.Assert(idxPage + 1 == this.pages.Count);
return;
case XmlEventType.DocType:
writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string) page[idxEvent].Object);
break;
case XmlEventType.StartElem:
writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.StartAttr:
writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.EndAttr:
writer.WriteEndAttribute();
break;
case XmlEventType.CData:
writer.WriteCData(page[idxEvent].String1);
break;
case XmlEventType.Comment:
writer.WriteComment(page[idxEvent].String1);
break;
case XmlEventType.PI:
writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2);
break;
case XmlEventType.Whitespace:
writer.WriteWhitespace(page[idxEvent].String1);
break;
case XmlEventType.String:
writer.WriteString(page[idxEvent].String1);
break;
case XmlEventType.Raw:
writer.WriteRaw(page[idxEvent].String1);
break;
case XmlEventType.EntRef:
writer.WriteEntityRef(page[idxEvent].String1);
break;
case XmlEventType.CharEnt:
writer.WriteCharEntity((char) page[idxEvent].Object);
break;
case XmlEventType.SurrCharEnt:
chars = (char[]) page[idxEvent].Object;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case XmlEventType.Base64:
bytes = (byte[]) page[idxEvent].Object;
writer.WriteBase64(bytes, 0, bytes.Length);
break;
case XmlEventType.BinHex:
bytes = (byte[]) page[idxEvent].Object;
writer.WriteBinHex(bytes, 0, bytes.Length);
break;
case XmlEventType.XmlDecl1:
if (rawWriter != null)
rawWriter.WriteXmlDeclaration((XmlStandalone) page[idxEvent].Object);
break;
case XmlEventType.XmlDecl2:
if (rawWriter != null)
rawWriter.WriteXmlDeclaration(page[idxEvent].String1);
break;
case XmlEventType.StartContent:
if (rawWriter != null)
rawWriter.StartElementContent();
break;
case XmlEventType.EndElem:
if (rawWriter != null)
rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
else
writer.WriteEndElement();
break;
case XmlEventType.FullEndElem:
if (rawWriter != null)
rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
else
writer.WriteFullEndElement();
break;
case XmlEventType.Nmsp:
if (rawWriter != null)
rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2);
else
writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2);
break;
case XmlEventType.EndBase64:
if (rawWriter != null)
rawWriter.WriteEndBase64();
break;
case XmlEventType.Close:
writer.Close();
break;
case XmlEventType.Flush:
writer.Flush();
break;
case XmlEventType.Dispose:
((IDisposable)writer).Dispose();
break;
default:
Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType);
break;
}
}
}
Debug.Assert(false, "Unknown event should be added to end of event sequence.");
}
protected override void WriteValue(XmlWriter writer, object value, bool logging)
{
byte[] bytes = (byte[])value;
using (new WriteXmlElement(writer, "base64"))
{
if (!logging)
writer.WriteBase64(bytes, 0, bytes.Length);
else
writer.WriteString(string.Format(CultureInfo.InvariantCulture, "[{0} bytes]", bytes.Length));
}
}
