Пример #1
0
		public virtual int read(java.nio.CharBuffer target)
		{
			int length = target.Length;
			char[] buf = new char[length];
			length = System.Math.Min(length, read(buf));
			if (length > 0)
			{
				target.put(buf, 0, length);
			}
			return length;
		}
Пример #2
0
		/// <summary>
		/// Decodes bytes starting at the current position of the given input buffer,
		/// and writes the equivalent character sequence into the given output buffer
		/// from its current position.
		/// </summary>
		/// <remarks>
		/// Decodes bytes starting at the current position of the given input buffer,
		/// and writes the equivalent character sequence into the given output buffer
		/// from its current position.
		/// <p>
		/// The buffers' position will be changed with the reading and writing
		/// operation, but their limits and marks will be kept intact.
		/// <p>
		/// A <code>CoderResult</code> instance will be returned according to
		/// following rules:
		/// <ul>
		/// <li>
		/// <see cref="CoderResult.OVERFLOW">CoderResult.OVERFLOW</see>
		/// indicates that
		/// even though not all of the input has been processed, the buffer the
		/// output is being written to has reached its capacity. In the event of this
		/// code being returned this method should be called once more with an
		/// <code>out</code> argument that has not already been filled.</li>
		/// <li>
		/// <see cref="CoderResult.UNDERFLOW">CoderResult.UNDERFLOW</see>
		/// indicates that
		/// as many bytes as possible in the input buffer have been decoded. If there
		/// is no further input and no remaining bytes in the input buffer then this
		/// operation may be regarded as complete. Otherwise, this method should be
		/// called once more with additional input.</li>
		/// <li>A
		/// <see cref="CoderResult.malformedForLength(int)">malformed input</see>
		/// result
		/// indicates that some malformed input error has been encountered, and the
		/// erroneous bytes start at the input buffer's position and their number can
		/// be got by result's
		/// <see cref="CoderResult.length()">length</see>
		/// . This kind of
		/// result can be returned only if the malformed action is
		/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
		/// . </li>
		/// <li>A
		/// <see cref="CoderResult.unmappableForLength(int)">unmappable character</see>
		/// result indicates that some unmappable character error has been
		/// encountered, and the erroneous bytes start at the input buffer's position
		/// and their number can be got by result's
		/// <see cref="CoderResult.length()">length</see>
		/// . This kind of result can be returned
		/// only if the unmappable character action is
		/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
		/// . </li>
		/// </ul>
		/// <p>
		/// The <code>endOfInput</code> parameter indicates that the invoker cannot
		/// provide further input. This parameter is true if and only if the bytes in
		/// current input buffer are all inputs for this decoding operation. Note
		/// that it is common and won't cause an error if the invoker sets false and
		/// then can't provide more input, while it may cause an error if the invoker
		/// always sets true in several consecutive invocations. This would make the
		/// remaining input to be treated as malformed input.
		/// <p>
		/// This method invokes the
		/// <see cref="decodeLoop(java.nio.ByteBuffer, java.nio.CharBuffer)">decodeLoop</see>
		/// method to
		/// implement the basic decode logic for a specific charset.
		/// </remarks>
		/// <param name="in">the input buffer.</param>
		/// <param name="out">the output buffer.</param>
		/// <param name="endOfInput">true if all the input characters have been provided.</param>
		/// <returns>
		/// a <code>CoderResult</code> instance which indicates the reason
		/// of termination.
		/// </returns>
		/// <exception cref="System.InvalidOperationException">
		/// if decoding has started or no more input is needed in this
		/// decoding progress.
		/// </exception>
		/// <exception cref="CoderMalfunctionError">
		/// if the
		/// <see cref="decodeLoop(java.nio.ByteBuffer, java.nio.CharBuffer)">decodeLoop</see>
		/// method threw an <code>BufferUnderflowException</code> or
		/// <code>BufferOverflowException</code>.
		/// </exception>
		public java.nio.charset.CoderResult decode(java.nio.ByteBuffer @in, java.nio.CharBuffer
			 @out, bool endOfInput)
		{
			if ((status == FLUSH) || (!endOfInput && status == END))
			{
				throw new System.InvalidOperationException();
			}
			java.nio.charset.CoderResult result = null;
			// begin to decode
			while (true)
			{
				java.nio.charset.CodingErrorAction action = null;
				try
				{
					result = decodeLoop(@in, @out);
				}
				catch (java.nio.BufferOverflowException ex)
				{
					// unexpected exception
					throw new java.nio.charset.CoderMalfunctionError(ex);
				}
				catch (java.nio.BufferUnderflowException ex)
				{
					// unexpected exception
					throw new java.nio.charset.CoderMalfunctionError(ex);
				}
				if (result.isUnderflow())
				{
					int remaining = @in.remaining();
					status = endOfInput ? END : ONGOING;
					if (endOfInput && remaining > 0)
					{
						result = java.nio.charset.CoderResult.malformedForLength(remaining);
					}
					else
					{
						return result;
					}
				}
				if (result.isOverflow())
				{
					return result;
				}
				// set coding error handle action
				action = _malformedInputAction;
				if (result.isUnmappable())
				{
					action = _unmappableCharacterAction;
				}
				// If the action is IGNORE or REPLACE, we should continue decoding.
				if (action == java.nio.charset.CodingErrorAction.REPLACE)
				{
					if (@out.remaining() < replacementChars.Length)
					{
						return java.nio.charset.CoderResult.OVERFLOW;
					}
					@out.put(replacementChars);
				}
				else
				{
					if (action != java.nio.charset.CodingErrorAction.IGNORE)
					{
						return result;
					}
				}
				@in.position(@in.position() + result.length());
			}
		}
 //-----------------------------------------------------------------------
 /**
  * Protects against adding null values to a map.
  * <p>
  * This method checks the value being added to the map, and if it is null
  * it is replaced by an empty string.
  * <p>
  * This could be useful if the map does not accept null values, or for
  * receiving data from a source that may provide null or empty string
  * which should be held in the same way in the map.
  * <p>
  * Keys are not validated.
  *
  * @param map  the map to add to, may not be null
  * @param key  the key
  * @param value  the value, null converted to ""
  * @throws NullPointerException if the map is null
  */
 public static void safeAddToMap(java.util.Map<Object, Object> map, Object key, Object value)
 {
     //throws NullPointerException {
     if (value == null)
     {
         map.put(key, "");
     }
     else
     {
         map.put(key, value);
     }
 }
Пример #4
0
		/// <summary>
		/// Encodes characters starting at the current position of the given input
		/// buffer, and writes the equivalent byte sequence into the given output
		/// buffer from its current position.
		/// </summary>
		/// <remarks>
		/// Encodes characters starting at the current position of the given input
		/// buffer, and writes the equivalent byte sequence into the given output
		/// buffer from its current position.
		/// <p>
		/// The buffers' position will be changed with the reading and writing
		/// operation, but their limits and marks will be kept intact.
		/// <p>
		/// A <code>CoderResult</code> instance will be returned according to
		/// following rules:
		/// <ul>
		/// <li>A
		/// <see cref="CoderResult.malformedForLength(int)">malformed input</see>
		/// result
		/// indicates that some malformed input error was encountered, and the
		/// erroneous characters start at the input buffer's position and their
		/// number can be got by result's
		/// <see cref="CoderResult.length()">length</see>
		/// . This
		/// kind of result can be returned only if the malformed action is
		/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
		/// .</li>
		/// <li>
		/// <see cref="CoderResult.UNDERFLOW">CoderResult.UNDERFLOW</see>
		/// indicates that
		/// as many characters as possible in the input buffer have been encoded. If
		/// there is no further input and no characters left in the input buffer then
		/// this task is complete. If this is not the case then the client should
		/// call this method again supplying some more input characters.</li>
		/// <li>
		/// <see cref="CoderResult.OVERFLOW">CoderResult.OVERFLOW</see>
		/// indicates that the
		/// output buffer has been filled, while there are still some characters
		/// remaining in the input buffer. This method should be invoked again with a
		/// non-full output buffer.</li>
		/// <li>A
		/// <see cref="CoderResult.unmappableForLength(int)">unmappable character</see>
		/// result indicates that some unmappable character error was encountered,
		/// and the erroneous characters start at the input buffer's position and
		/// their number can be got by result's
		/// <see cref="CoderResult.length()">length</see>
		/// .
		/// This kind of result can be returned only on
		/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
		/// .</li>
		/// </ul>
		/// <p>
		/// The <code>endOfInput</code> parameter indicates if the invoker can
		/// provider further input. This parameter is true if and only if the
		/// characters in the current input buffer are all inputs for this encoding
		/// operation. Note that it is common and won't cause an error if the invoker
		/// sets false and then has no more input available, while it may cause an
		/// error if the invoker always sets true in several consecutive invocations.
		/// This would make the remaining input to be treated as malformed input.
		/// input.
		/// <p>
		/// This method invokes the
		/// <see cref="encodeLoop(java.nio.CharBuffer, java.nio.ByteBuffer)">encodeLoop</see>
		/// method to
		/// implement the basic encode logic for a specific charset.
		/// </remarks>
		/// <param name="in">the input buffer.</param>
		/// <param name="out">the output buffer.</param>
		/// <param name="endOfInput">true if all the input characters have been provided.</param>
		/// <returns>a <code>CoderResult</code> instance indicating the result.</returns>
		/// <exception cref="System.InvalidOperationException">
		/// if the encoding operation has already started or no more
		/// input is needed in this encoding process.
		/// </exception>
		/// <exception cref="CoderMalfunctionError">
		/// If the
		/// <see cref="encodeLoop(java.nio.CharBuffer, java.nio.ByteBuffer)">encodeLoop</see>
		/// method threw an <code>BufferUnderflowException</code> or
		/// <code>BufferUnderflowException</code>.
		/// </exception>
		public java.nio.charset.CoderResult encode(java.nio.CharBuffer @in, java.nio.ByteBuffer
			 @out, bool endOfInput)
		{
			// If the previous step is encode(CharBuffer), then no more input is needed
			// thus endOfInput should not be false
			if (status == READY && finished && !endOfInput)
			{
				throw new System.InvalidOperationException();
			}
			if ((status == FLUSH) || (!endOfInput && status == END))
			{
				throw new System.InvalidOperationException();
			}
			java.nio.charset.CoderResult result;
			while (true)
			{
				try
				{
					result = encodeLoop(@in, @out);
				}
				catch (java.nio.BufferOverflowException e)
				{
					throw new java.nio.charset.CoderMalfunctionError(e);
				}
				catch (java.nio.BufferUnderflowException e)
				{
					throw new java.nio.charset.CoderMalfunctionError(e);
				}
				if (result == java.nio.charset.CoderResult.UNDERFLOW)
				{
					status = endOfInput ? END : ONGOING;
					if (endOfInput)
					{
						int remaining = @in.remaining();
						if (remaining > 0)
						{
							result = java.nio.charset.CoderResult.malformedForLength(remaining);
						}
						else
						{
							return result;
						}
					}
					else
					{
						return result;
					}
				}
				else
				{
					if (result == java.nio.charset.CoderResult.OVERFLOW)
					{
						status = endOfInput ? END : ONGOING;
						return result;
					}
				}
				java.nio.charset.CodingErrorAction action = _malformedInputAction;
				if (result.isUnmappable())
				{
					action = _unmappableCharacterAction;
				}
				// If the action is IGNORE or REPLACE, we should continue
				// encoding.
				if (action == java.nio.charset.CodingErrorAction.REPLACE)
				{
					if (@out.remaining() < replacementBytes.Length)
					{
						return java.nio.charset.CoderResult.OVERFLOW;
					}
					@out.put(replacementBytes);
				}
				else
				{
					if (action != java.nio.charset.CodingErrorAction.IGNORE)
					{
						return result;
					}
				}
				@in.position(@in.position() + result.length());
			}
		}
 //-----------------------------------------------------------------------
 /**
  * Puts all the keys and values from the specified array into the map.
  * <p>
  * This method is an alternative to the {@link java.util.Map#putAll(java.util.Map)}
  * method and constructors. It allows you to build a map from an object array
  * of various possible styles.
  * <p>
  * If the first entry in the object array implements {@link java.util.Map.Entry}
  * or {@link KeyValue} then the key and value are added from that object.
  * If the first entry in the object array is an object array itself, then
  * it is assumed that index 0 in the sub-array is the key and index 1 is the value.
  * Otherwise, the array is treated as keys and values in alternate indices.
  * <p>
  * For example, to create a color map:
  * <pre>
  * Map colorMap = MapUtils.putAll(new HashMap(), new String[][] {
  *     {"RED", "#FF0000"},
  *     {"GREEN", "#00FF00"},
  *     {"BLUE", "#0000FF"}
  * });
  * </pre>
  * or:
  * <pre>
  * Map colorMap = MapUtils.putAll(new HashMap(), new String[] {
  *     "RED", "#FF0000",
  *     "GREEN", "#00FF00",
  *     "BLUE", "#0000FF"
  * });
  * </pre>
  * or:
  * <pre>
  * Map colorMap = MapUtils.putAll(new HashMap(), new Map.Entry[] {
  *     new DefaultMapEntry("RED", "#FF0000"),
  *     new DefaultMapEntry("GREEN", "#00FF00"),
  *     new DefaultMapEntry("BLUE", "#0000FF")
  * });
  * </pre>
  *
  * @param map  the map to populate, must not be null
  * @param array  an array to populate from, null ignored
  * @return the input map
  * @throws NullPointerException  if map is null
  * @throws IllegalArgumentException  if sub-array or entry matching used and an
  *  entry is invalid
  * @throws ClassCastException if the array contents is mixed
  * @since Commons Collections 3.2
  */
 public static java.util.Map<Object, Object> putAll(java.util.Map<Object, Object> map, Object[] array)
 {
     map.size();  // force NPE
     if (array == null || array.Length == 0)
     {
         return map;
     }
     Object obj = array[0];
     if (obj is java.util.MapNS.Entry<Object, Object>)
     {
         for (int i = 0; i < array.Length; i++)
         {
             java.util.MapNS.Entry<Object, Object> entry = (java.util.MapNS.Entry<Object, Object>)array[i];
             map.put(entry.getKey(), entry.getValue());
         }
     }
     else if (obj is KeyValue)
     {
         for (int i = 0; i < array.Length; i++)
         {
             KeyValue keyval = (KeyValue)array[i];
             map.put(keyval.getKey(), keyval.getValue());
         }
     }
     else if (obj is Object[])
     {
         for (int i = 0; i < array.Length; i++)
         {
             Object[] sub = (Object[])array[i];
             if (sub == null || sub.Length < 2)
             {
                 throw new java.lang.IllegalArgumentException("Invalid array element: " + i);
             }
             map.put(sub[0], sub[1]);
         }
     }
     else
     {
         for (int i = 0; i < array.Length - 1; )
         {
             map.put(array[i++], array[i++]);
         }
     }
     return map;
 }