/// <exception cref="System.IO.IOException"></exception>
 private void WriteObject(ObjectOutputStream @out)
 {
     @out.WriteObject(cookie.GetName());
     @out.WriteObject(cookie.GetValue());
     @out.WriteObject(cookie.GetComment());
     @out.WriteObject(cookie.GetDomain());
     @out.WriteObject(cookie.GetExpiryDate());
     @out.WriteObject(cookie.GetPath());
     @out.WriteInt(cookie.GetVersion());
     @out.WriteBoolean(cookie.IsSecure());
 }
Beispiel #2
0
		/// <exception cref="System.IO.IOException"></exception>
		private void WriteObject(ObjectOutputStream os)
		{
			os.WriteInt(w1);
			os.WriteInt(w2);
			os.WriteInt(w3);
			os.WriteInt(w4);
			os.WriteInt(w5);
		}
Beispiel #3
0
		/// <exception cref="System.IO.IOException"></exception>
		private void WriteObject(ObjectOutputStream os)
		{
			os.DefaultWriteObject();
			int N = size;
			for (int i = 0; i != N; ++i)
			{
				object obj = GetImpl(i);
				os.WriteObject(obj);
			}
		}
Beispiel #4
0
		// end encodeObject
		/// <summary>
		/// Serializes an object and returns the Base64-encoded
		/// version of that serialized object.
		/// </summary>
		/// <remarks>
		/// Serializes an object and returns the Base64-encoded
		/// version of that serialized object.
		/// <p>As of v 2.3, if the object
		/// cannot be serialized or there is another error,
		/// the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
		/// In earlier versions, it just returned a null value, but
		/// in retrospect that's a pretty poor way to handle it.</p>
		/// The object is not GZip-compressed before being encoded.
		/// <p>
		/// Example options:<pre>
		/// GZIP: gzip-compresses object before encoding it.
		/// DO_BREAK_LINES: break lines at 76 characters
		/// </pre>
		/// <p>
		/// Example: <code>encodeObject( myObj, Base64.GZIP )</code> or
		/// <p>
		/// Example: <code>encodeObject( myObj, Base64.GZIP | Base64.DO_BREAK_LINES )</code>
		/// </remarks>
		/// <param name="serializableObject">The object to encode</param>
		/// <param name="options">Specified options</param>
		/// <returns>The Base64-encoded object</returns>
		/// <seealso cref="Gzip">Gzip</seealso>
		/// <seealso cref="DoBreakLines">DoBreakLines</seealso>
		/// <exception cref="System.IO.IOException">if there is an error</exception>
		/// <since>2.0</since>
		public static string EncodeObject(Serializable serializableObject, int options)
		{
			if (serializableObject == null)
			{
				throw new ArgumentNullException("Cannot serialize a null object.");
			}
			// end if: null
			// Streams
			ByteArrayOutputStream baos = null;
			OutputStream b64os = null;
			GZIPOutputStream gzos = null;
			ObjectOutputStream oos = null;
			try
			{
				// ObjectOutputStream -> (GZIP) -> Base64 -> ByteArrayOutputStream
				baos = new ByteArrayOutputStream();
				b64os = new Base64.OutputStream(baos, Encode | options);
				if ((options & Gzip) != 0)
				{
					// Gzip
					gzos = new GZIPOutputStream(b64os);
					oos = new ObjectOutputStream(gzos);
				}
				else
				{
					// Not gzipped
					oos = new ObjectOutputStream(b64os);
				}
				oos.WriteObject(serializableObject);
			}
			catch (IOException e)
			{
				// end try
				// Catch it and then throw it immediately so that
				// the finally{} block is called for cleanup.
				throw;
			}
			finally
			{
				// end catch
				try
				{
					oos.Close();
				}
				catch (Exception)
				{
				}
				try
				{
					gzos.Close();
				}
				catch (Exception)
				{
				}
				try
				{
					b64os.Close();
				}
				catch (Exception)
				{
				}
				try
				{
					baos.Close();
				}
				catch (Exception)
				{
				}
			}
			// end finally
			// Return value according to relevant encoding.
			try
			{
				return Sharpen.Runtime.GetStringForBytes(baos.ToByteArray(), PreferredEncoding);
			}
			catch (UnsupportedEncodingException)
			{
				// end try
				// Fall back to some Java default
				return Sharpen.Runtime.GetStringForBytes(baos.ToByteArray());
			}
		}
Beispiel #5
0
		/// <exception cref="System.IO.IOException"></exception>
		private void WriteObject(ObjectOutputStream stream)
		{
			stream.DefaultWriteObject();
			int maxPrototypeId = 0;
			if (prototypeValues != null)
			{
				maxPrototypeId = prototypeValues.GetMaxId();
			}
			stream.WriteInt(maxPrototypeId);
		}
		public virtual void TestConsStringSerialization()
		{
			ConsString r1 = new ConsString("foo", "bar");
			MemoryStream baos = new MemoryStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.WriteObject(r1);
			oos.Flush();
			MemoryStream bais = new MemoryStream(baos.ToArray());
			ObjectInputStream ois = new ObjectInputStream(bais);
			CharSequence r2 = (CharSequence)ois.ReadObject();
			NUnit.Framework.Assert.AreEqual("still the same at the other end", r1.ToString(), r2.ToString());
		}
		public virtual void TestContinuationsPrototypesAndSerialization()
		{
			byte[] serializedData = null;
			{
				Scriptable globalScope;
				Context cx = Context.Enter();
				try
				{
					globalScope = cx.InitStandardObjects();
					cx.SetOptimizationLevel(-1);
					// must use interpreter mode
					globalScope.Put("myObject", globalScope, Context.JavaToJS(new ContinuationsApiTest.MyClass(), globalScope));
				}
				finally
				{
					Context.Exit();
				}
				cx = Context.Enter();
				try
				{
					cx.SetOptimizationLevel(-1);
					// must use interpreter mode
					cx.EvaluateString(globalScope, "function f(a) { Number.prototype.blargh = function() {return 'foo';}; var k = myObject.f(a); var t = []; return new Number(8).blargh(); }", "function test source", 1, null);
					Function f = (Function)globalScope.Get("f", globalScope);
					object[] args = new object[] { 7 };
					cx.CallFunctionWithContinuations(f, globalScope, args);
					NUnit.Framework.Assert.Fail("Should throw ContinuationPending");
				}
				catch (ContinuationPending pending)
				{
					// serialize
					MemoryStream baos = new MemoryStream();
					ObjectOutputStream sos = new ObjectOutputStream(baos);
					sos.WriteObject(globalScope);
					sos.WriteObject(pending.GetContinuation());
					sos.Close();
					baos.Close();
					serializedData = baos.ToArray();
				}
				finally
				{
					Context.Exit();
				}
			}
			{
				try
				{
					Context cx = Context.Enter();
					Scriptable globalScope;
					// deserialize
					MemoryStream bais = new MemoryStream(serializedData);
					ObjectInputStream sis = new ObjectInputStream(bais);
					globalScope = (Scriptable)sis.ReadObject();
					object continuation = sis.ReadObject();
					sis.Close();
					bais.Close();
					object result = cx.ResumeContinuation(continuation, globalScope, 8);
					NUnit.Framework.Assert.AreEqual("foo", result);
				}
				finally
				{
					Context.Exit();
				}
			}
		}
Beispiel #8
0
		/// <exception cref="System.IO.IOException"></exception>
		private void WriteObject(ObjectOutputStream @out)
		{
			@out.DefaultWriteObject();
			int count = keyCount;
			for (int i = 0; count != 0; ++i)
			{
				object key = keys[i];
				if (key != null && key != DELETED)
				{
					--count;
					@out.WriteObject(key);
					@out.WriteInt(values[i]);
				}
			}
		}
Beispiel #9
0
		/// <exception cref="System.IO.IOException"></exception>
		private void WriteObject(ObjectOutputStream @out)
		{
			@out.DefaultWriteObject();
			int count = keyCount;
			if (count != 0)
			{
				bool hasIntValues = (ivaluesShift != 0);
				bool hasObjectValues = (values != null);
				@out.WriteBoolean(hasIntValues);
				@out.WriteBoolean(hasObjectValues);
				for (int i = 0; count != 0; ++i)
				{
					int key = keys[i];
					if (key != EMPTY && key != DELETED)
					{
						--count;
						@out.WriteInt(key);
						if (hasIntValues)
						{
							@out.WriteInt(keys[ivaluesShift + i]);
						}
						if (hasObjectValues)
						{
							@out.WriteObject(values[i]);
						}
					}
				}
			}
		}