protected void SendOutPDF(System.IO.MemoryStream PDFData) { // Clear response content & headers Response.Clear(); Response.ClearContent(); Response.ClearHeaders(); Response.ContentType = "application/pdf"; Response.Charset = string.Empty; Response.Cache.SetCacheability(System.Web.HttpCacheability.Public); Response.AddHeader("Content-Disposition", "attachment; filename=Ticket.pdf"); Response.OutputStream.Write(PDFData.GetBuffer(), 0, PDFData.GetBuffer().Length); Response.OutputStream.Flush(); Response.OutputStream.Close(); Response.End(); }
private static char[] GetChars(System.IO.MemoryStream b, Encoding e) { return e.GetChars(b.GetBuffer(), 0, (int)b.Length); }
public static float[] FloatArrayFromStream(System.IO.MemoryStream stream) { return FloatArrayFromByteArray(stream.GetBuffer()); }
/// <summary> Decodes the input char sequence into the output byte sequence. Before /// calling this method, ensure that the output ByteBuffer has sufficient /// capacity by calling {@link #GetDecodedLength(java.nio.CharBuffer)}. /// /// </summary> /// <param name="input">The char sequence to decode /// </param> /// <param name="output">Where the byte sequence decoding result will go. The limit /// is set to one past the position of the final char. /// </param> /// <throws> IllegalArgumentException If either the input or the output buffer </throws> /// <summary> is not backed by an array /// </summary> public static void Decode(System.IO.MemoryStream input, System.IO.MemoryStream output) { // if (input.hasArray() && output.hasArray()) // {{Aroush-2.9}} { // int numInputChars = input.limit() - input.arrayOffset() - 1; // {{Aroush-2.9}} long numInputChars = input.Capacity - input.Position - 1; int numOutputBytes = GetDecodedLength(input); // output.limit(numOutputBytes + output.arrayOffset()); // Set output final pos + 1 // {{Aroush-2.9}} output.Capacity = (int) (numOutputBytes + output.Position); // output.position(0); // {{Aroush-2.9}} output.Position = 0; // byte[] outputArray = output.array(); // {{Aroush-2.9}} byte[] outputArray = output.GetBuffer(); // char[] inputArray = input.array(); // {{Aroush-2.9}} byte[] inputArray = (byte[]) input.GetBuffer(); if (numOutputBytes > 0) { int caseNum = 0; // int outputByteNum = output.arrayOffset(); // {{Aroush-2.9}} long outputByteNum = output.Position; // int inputCharNum = input.arrayOffset(); // {{Aroush-2.9}} long inputCharNum = input.Position; short inputChar; CodingCase codingCase; for (; inputCharNum < numInputChars - 1; ++inputCharNum) { codingCase = CODING_CASES[caseNum]; inputChar = (short) inputArray[inputCharNum]; if (2 == codingCase.numBytes) { if (0 == caseNum) { outputArray[outputByteNum] = (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift)); } else { outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift))); } outputArray[outputByteNum + 1] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift); } else { // numBytes is 3 outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift))); outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.middleMask), codingCase.middleShift)); outputArray[outputByteNum + 2] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift); } outputByteNum += codingCase.advanceBytes; if (++caseNum == CODING_CASES.Length) { caseNum = 0; } } // Handle final char inputChar = (short) inputArray[inputCharNum]; codingCase = CODING_CASES[caseNum]; if (0 == caseNum) { outputArray[outputByteNum] = 0; } outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift))); long bytesLeft = numOutputBytes - outputByteNum; if (bytesLeft > 1) { if (2 == codingCase.numBytes) { outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.finalMask), codingCase.finalShift)); } else { // numBytes is 3 outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.middleMask), codingCase.middleShift)); if (bytesLeft > 2) { outputArray[outputByteNum + 2] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift); } } } } } // else // {{Aroush-2.9}} // { // throw new System.ArgumentException("Arguments must have backing arrays"); // {{Aroush-2.9}} // } }
/// <summary> Encodes the input byte sequence into the output char sequence. Before /// calling this method, ensure that the output CharBuffer has sufficient /// capacity by calling {@link #GetEncodedLength(java.nio.ByteBuffer)}. /// /// </summary> /// <param name="input">The byte sequence to encode /// </param> /// <param name="output">Where the char sequence encoding result will go. The limit /// is set to one past the position of the final char. /// </param> /// <throws> IllegalArgumentException If either the input or the output buffer </throws> /// <summary> is not backed by an array /// </summary> public static void Encode(System.IO.MemoryStream input, System.IO.MemoryStream output) { // if (input.hasArray() && output.hasArray()) // {{Aroush-2.9}} { // byte[] inputArray = input.array(); // {{Aroush-2.9}} byte[] inputArray = input.GetBuffer(); // int inputOffset = input.arrayOffset(); // {{Aroush-2.9}} long inputOffset = input.Position; // int inputLength = input.limit() - inputOffset; // {{Aroush-2.9}} long inputLength = input.Capacity - inputOffset; // char[] outputArray = output.array(); // {{Aroush-2.9}} byte[] outputArray = output.GetBuffer(); // int outputOffset = output.arrayOffset(); // {{Aroush-2.9}} long outputOffset = output.Position; int outputLength = GetEncodedLength(input); // output.limit(outputOffset + outputLength); // Set output final pos + 1 // {{Aroush-2.9}} output.Position = outputOffset + outputLength; // output.position(0); // {{Aroush-2.9}} output.Position = 0; if (inputLength > 0) { long inputByteNum = inputOffset; int caseNum = 0; long outputCharNum = outputOffset; CodingCase codingCase; for (; inputByteNum + CODING_CASES[caseNum].numBytes <= inputLength; ++outputCharNum) { codingCase = CODING_CASES[caseNum]; if (2 == codingCase.numBytes) { outputArray[outputCharNum] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((SupportClass.Number.URShift((inputArray[inputByteNum + 1] & 0xFF), codingCase.finalShift)) & codingCase.finalMask) & (short) 0x7FFF); } else { // numBytes is 3 outputArray[outputCharNum] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift) + ((SupportClass.Number.URShift((inputArray[inputByteNum + 2] & 0xFF), codingCase.finalShift)) & codingCase.finalMask) & (short) 0x7FFF); } inputByteNum += codingCase.advanceBytes; if (++caseNum == CODING_CASES.Length) { caseNum = 0; } } // Produce final char (if any) and trailing count chars. codingCase = CODING_CASES[caseNum]; if (inputByteNum + 1 < inputLength) { // codingCase.numBytes must be 3 outputArray[outputCharNum++] = (byte) ((((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift)) & (short) 0x7FFF); // Add trailing char containing the number of full bytes in final char outputArray[outputCharNum++] = (byte) 1; } else if (inputByteNum < inputLength) { outputArray[outputCharNum++] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) & (short) 0x7FFF); // Add trailing char containing the number of full bytes in final char outputArray[outputCharNum++] = caseNum == 0?(byte) 1:(byte) 0; } else { // No left over bits - last char is completely filled. // Add trailing char containing the number of full bytes in final char outputArray[outputCharNum++] = (byte) 1; } } } // else // {{Aroush-2.9}} // { // throw new System.ArgumentException("Arguments must have backing arrays"); // {{Aroush-2.9}} // } }