/// <summary>
		/// Encodes the UInt32.
		/// http://tools.ietf.org/html/rfc4506#section-4.2
		/// </summary>
		public static void EncodeUInt32(uint v, IByteWriter w)
		{
			w.Write((byte)((v >> 0x18) & 0xff));
			w.Write((byte)((v >> 0x10) & 0xff));
			w.Write((byte)((v >> 8) & 0xff));
			w.Write((byte)(v & 0xff));
		}

 public BatchWriter(IByteWriter target, int maxBufferSizeInBytes)
 {
     _target = target;
     _pendingBuffer = new ByteBuffer(maxBufferSizeInBytes);
     _flushBuffer = new ByteBuffer(maxBufferSizeInBytes);
     _minFlushSize = maxBufferSizeInBytes/2;
 }

 public static void Encode(IByteWriter stream, ManageOfferOp encodedManageOfferOp) {
   Asset.Encode(stream, encodedManageOfferOp.Selling);
   Asset.Encode(stream, encodedManageOfferOp.Buying);
   Int64.Encode(stream, encodedManageOfferOp.Amount);
   Price.Encode(stream, encodedManageOfferOp.Price);
   Uint64.Encode(stream, encodedManageOfferOp.OfferID);
 }

 public static void Encode(IByteWriter stream, StellarValueExt encodedStellarValueExt) {
 XdrEncoding.EncodeInt32(encodedStellarValueExt.Discriminant, stream);
 switch (encodedStellarValueExt.Discriminant) {
 case 0:
 break;
 }
 }

 public static void Encode(IByteWriter stream, OfferEntryExt encodedOfferEntryExt) {
 XdrEncoding.EncodeInt32(encodedOfferEntryExt.Discriminant, stream);
 switch (encodedOfferEntryExt.Discriminant) {
 case 0:
 break;
 }
 }

 public static void Encode(IByteWriter stream, LedgerEntryChanges  encodedLedgerEntryChanges) {
 int LedgerEntryChangesSize = encodedLedgerEntryChanges.InnerValue.Length;
 XdrEncoding.EncodeInt32(LedgerEntryChangesSize, stream);
 for (int i = 0; i < LedgerEntryChangesSize; i++) {
   LedgerEntryChange.Encode(stream, encodedLedgerEntryChanges.InnerValue[i]);
 }
 }

 public static void Encode(IByteWriter stream, TransactionResultSet encodedTransactionResultSet) {
   int resultssize = encodedTransactionResultSet.Results.Length;
   XdrEncoding.EncodeInt32(resultssize, stream);
   for (int i = 0; i < resultssize; i++) {
     TransactionResultPair.Encode(stream, encodedTransactionResultSet.Results[i]);
   }
 }

 public static void Encode(IByteWriter stream, TransactionHistoryResultEntryExt encodedTransactionHistoryResultEntryExt) {
 XdrEncoding.EncodeInt32(encodedTransactionHistoryResultEntryExt.Discriminant, stream);
 switch (encodedTransactionHistoryResultEntryExt.Discriminant) {
 case 0:
 break;
 }
 }

 public static void Encode(IByteWriter stream, LedgerHeaderHistoryEntryExt encodedLedgerHeaderHistoryEntryExt) {
 XdrEncoding.EncodeInt32(encodedLedgerHeaderHistoryEntryExt.Discriminant, stream);
 switch (encodedLedgerHeaderHistoryEntryExt.Discriminant) {
 case 0:
 break;
 }
 }

 public static void Encode(IByteWriter stream, AuthenticatedMessage encodedAuthenticatedMessage) {
 XdrEncoding.EncodeInt32((int)encodedAuthenticatedMessage.Discriminant.InnerValue, stream);
 switch (encodedAuthenticatedMessage.Discriminant.InnerValue) {
 case 0:
 AuthenticatedMessageV0.Encode(stream, encodedAuthenticatedMessage.V0);
 break;
 }
 }

 public static void Encode(IByteWriter stream, PublicKey encodedPublicKey) {
 XdrEncoding.EncodeInt32((int)encodedPublicKey.Discriminant.InnerValue, stream);
 switch (encodedPublicKey.Discriminant.InnerValue) {
 case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_ED25519:
 Uint256.Encode(stream, encodedPublicKey.Ed25519);
 break;
 }
 }

 public static void Encode(IByteWriter stream, TransactionSet encodedTransactionSet) {
   Hash.Encode(stream, encodedTransactionSet.PreviousLedgerHash);
   int txssize = encodedTransactionSet.Txs.Length;
   XdrEncoding.EncodeInt32(txssize, stream);
   for (int i = 0; i < txssize; i++) {
     TransactionEnvelope.Encode(stream, encodedTransactionSet.Txs[i]);
   }
 }

 public static void Encode(IByteWriter stream, TransactionEnvelope encodedTransactionEnvelope) {
   Transaction.Encode(stream, encodedTransactionEnvelope.Tx);
   int signaturessize = encodedTransactionEnvelope.Signatures.Length;
   XdrEncoding.EncodeInt32(signaturessize, stream);
   for (int i = 0; i < signaturessize; i++) {
     DecoratedSignature.Encode(stream, encodedTransactionEnvelope.Signatures[i]);
   }
 }

 public static void Encode(IByteWriter stream, TrustLineEntry encodedTrustLineEntry) {
   AccountID.Encode(stream, encodedTrustLineEntry.AccountID);
   Asset.Encode(stream, encodedTrustLineEntry.Asset);
   Int64.Encode(stream, encodedTrustLineEntry.Balance);
   Int64.Encode(stream, encodedTrustLineEntry.Limit);
   Uint32.Encode(stream, encodedTrustLineEntry.Flags);
   TrustLineEntryExt.Encode(stream, encodedTrustLineEntry.Ext);
 }

 public static void Encode(IByteWriter stream, LedgerSCPMessages encodedLedgerSCPMessages) {
   Uint32.Encode(stream, encodedLedgerSCPMessages.LedgerSeq);
   int messagessize = encodedLedgerSCPMessages.Messages.Length;
   XdrEncoding.EncodeInt32(messagessize, stream);
   for (int i = 0; i < messagessize; i++) {
     SCPEnvelope.Encode(stream, encodedLedgerSCPMessages.Messages[i]);
   }
 }

 public static void Encode(IByteWriter stream, PathPaymentResultSuccess encodedPathPaymentResultSuccess) {
   int offerssize = encodedPathPaymentResultSuccess.Offers.Length;
   XdrEncoding.EncodeInt32(offerssize, stream);
   for (int i = 0; i < offerssize; i++) {
     ClaimOfferAtom.Encode(stream, encodedPathPaymentResultSuccess.Offers[i]);
   }
   SimplePaymentResult.Encode(stream, encodedPathPaymentResultSuccess.Last);
 }

 public static void Encode(IByteWriter stream, ClaimOfferAtom encodedClaimOfferAtom) {
   AccountID.Encode(stream, encodedClaimOfferAtom.SellerID);
   Uint64.Encode(stream, encodedClaimOfferAtom.OfferID);
   Asset.Encode(stream, encodedClaimOfferAtom.AssetSold);
   Int64.Encode(stream, encodedClaimOfferAtom.AmountSold);
   Asset.Encode(stream, encodedClaimOfferAtom.AssetBought);
   Int64.Encode(stream, encodedClaimOfferAtom.AmountBought);
 }

 public static void Encode(IByteWriter stream, ManageOfferSuccessResult encodedManageOfferSuccessResult) {
   int offersClaimedsize = encodedManageOfferSuccessResult.OffersClaimed.Length;
   XdrEncoding.EncodeInt32(offersClaimedsize, stream);
   for (int i = 0; i < offersClaimedsize; i++) {
     ClaimOfferAtom.Encode(stream, encodedManageOfferSuccessResult.OffersClaimed[i]);
   }
   ManageOfferSuccessResultOffer.Encode(stream, encodedManageOfferSuccessResult.Offer);
 }

 public static void Encode(IByteWriter stream, SCPHistoryEntryV0 encodedSCPHistoryEntryV0) {
   int quorumSetssize = encodedSCPHistoryEntryV0.QuorumSets.Length;
   XdrEncoding.EncodeInt32(quorumSetssize, stream);
   for (int i = 0; i < quorumSetssize; i++) {
     SCPQuorumSet.Encode(stream, encodedSCPHistoryEntryV0.QuorumSets[i]);
   }
   LedgerSCPMessages.Encode(stream, encodedSCPHistoryEntryV0.LedgerMessages);
 }

 public static void Encode(IByteWriter stream, SCPHistoryEntry encodedSCPHistoryEntry) {
 XdrEncoding.EncodeInt32(encodedSCPHistoryEntry.Discriminant, stream);
 switch (encodedSCPHistoryEntry.Discriminant) {
 case 0:
 SCPHistoryEntryV0.Encode(stream, encodedSCPHistoryEntry.V0);
 break;
 }
 }