126 lines
4.3 KiB
C#
126 lines
4.3 KiB
C#
|
|
//------------------------------------------------------------------------------
|
|
// <copyright file="Base64Encoder.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">Microsoft</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System.Text;
|
|
using System.Diagnostics;
|
|
|
|
namespace System.Xml {
|
|
|
|
internal abstract partial class Base64Encoder {
|
|
|
|
byte[] leftOverBytes;
|
|
int leftOverBytesCount;
|
|
char[] charsLine;
|
|
|
|
internal const int Base64LineSize = 76;
|
|
internal const int LineSizeInBytes = Base64LineSize/4*3;
|
|
|
|
internal Base64Encoder() {
|
|
charsLine = new char[Base64LineSize];
|
|
}
|
|
|
|
internal abstract void WriteChars( char[] chars, int index, int count );
|
|
|
|
internal void Encode( byte[] buffer, int index, int count ) {
|
|
if ( buffer == null ) {
|
|
throw new ArgumentNullException( "buffer" );
|
|
}
|
|
if ( index < 0 ) {
|
|
throw new ArgumentOutOfRangeException( "index" );
|
|
}
|
|
if ( count < 0 ) {
|
|
throw new ArgumentOutOfRangeException( "count" );
|
|
}
|
|
if ( count > buffer.Length - index ) {
|
|
throw new ArgumentOutOfRangeException( "count" );
|
|
}
|
|
|
|
// encode left-over buffer
|
|
if( leftOverBytesCount > 0 ) {
|
|
int i = leftOverBytesCount;
|
|
while ( i < 3 && count > 0 ) {
|
|
leftOverBytes[i++] = buffer[index++];
|
|
count--;
|
|
}
|
|
|
|
// the total number of buffer we have is less than 3 -> return
|
|
if ( count == 0 && i < 3 ) {
|
|
leftOverBytesCount = i;
|
|
return;
|
|
}
|
|
|
|
// encode the left-over buffer and write out
|
|
int leftOverChars = Convert.ToBase64CharArray( leftOverBytes, 0, 3, charsLine, 0 );
|
|
WriteChars( charsLine, 0, leftOverChars );
|
|
}
|
|
|
|
// store new left-over buffer
|
|
leftOverBytesCount = count % 3;
|
|
if ( leftOverBytesCount > 0 ) {
|
|
count -= leftOverBytesCount;
|
|
if ( leftOverBytes == null ) {
|
|
leftOverBytes = new byte[3];
|
|
}
|
|
for( int i = 0; i < leftOverBytesCount; i++ ) {
|
|
leftOverBytes[i] = buffer[ index + count + i ];
|
|
}
|
|
}
|
|
|
|
// encode buffer in 76 character long chunks
|
|
int endIndex = index + count;
|
|
int chunkSize = LineSizeInBytes;
|
|
while( index < endIndex ) {
|
|
if ( index + chunkSize > endIndex ) {
|
|
chunkSize = endIndex - index;
|
|
}
|
|
int charCount = Convert.ToBase64CharArray( buffer, index, chunkSize, charsLine, 0 );
|
|
WriteChars( charsLine, 0, charCount );
|
|
|
|
index += chunkSize;
|
|
}
|
|
}
|
|
|
|
internal void Flush() {
|
|
if ( leftOverBytesCount > 0 ) {
|
|
int leftOverChars = Convert.ToBase64CharArray( leftOverBytes, 0, leftOverBytesCount, charsLine, 0 );
|
|
WriteChars( charsLine, 0, leftOverChars );
|
|
leftOverBytesCount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal partial class XmlRawWriterBase64Encoder : Base64Encoder {
|
|
|
|
XmlRawWriter rawWriter;
|
|
|
|
internal XmlRawWriterBase64Encoder( XmlRawWriter rawWriter ) {
|
|
this.rawWriter = rawWriter;
|
|
}
|
|
|
|
internal override void WriteChars( char[] chars, int index, int count ) {
|
|
rawWriter.WriteRaw( chars, index, count );
|
|
}
|
|
}
|
|
|
|
#if !SILVERLIGHT || FEATURE_NETCORE
|
|
internal partial class XmlTextWriterBase64Encoder : Base64Encoder {
|
|
|
|
XmlTextEncoder xmlTextEncoder;
|
|
|
|
internal XmlTextWriterBase64Encoder( XmlTextEncoder xmlTextEncoder ) {
|
|
this.xmlTextEncoder = xmlTextEncoder;
|
|
}
|
|
|
|
internal override void WriteChars( char[] chars, int index, int count ) {
|
|
xmlTextEncoder.WriteRaw( chars, index, count );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|