View Javadoc

1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License.
18   *
19   */
20  package org.apache.mina.core.buffer;
21  
22  import java.io.IOException;
23  import java.io.InputStream;
24  import java.io.OutputStream;
25  import java.nio.BufferOverflowException;
26  import java.nio.ByteBuffer;
27  import java.nio.ByteOrder;
28  import java.nio.CharBuffer;
29  import java.nio.DoubleBuffer;
30  import java.nio.FloatBuffer;
31  import java.nio.IntBuffer;
32  import java.nio.LongBuffer;
33  import java.nio.ReadOnlyBufferException;
34  import java.nio.ShortBuffer;
35  import java.nio.charset.CharacterCodingException;
36  import java.nio.charset.CharsetDecoder;
37  import java.nio.charset.CharsetEncoder;
38  import java.util.EnumSet;
39  import java.util.Set;
40  
41  import org.apache.mina.core.session.IoSession;
42  
43  /**
44   * A byte buffer used by MINA applications.
45   * <p>
46   * This is a replacement for {@link ByteBuffer}. Please refer to
47   * {@link ByteBuffer} documentation for preliminary usage. MINA does not use NIO
48   * {@link ByteBuffer} directly for two reasons:
49   * <ul>
50   * <li>It doesn't provide useful getters and putters such as <code>fill</code>,
51   * <code>get/putString</code>, and <code>get/putAsciiInt()</code> enough.</li>
52   * <li>It is difficult to write variable-length data due to its fixed capacity</li>
53   * </ul>
54   * </p>
55   * 
56   * <h2>Allocation</h2>
57   * <p>
58   * You can allocate a new heap buffer.
59   * 
60   * <pre>
61   * IoBuffer buf = IoBuffer.allocate(1024, false);
62   * </pre>
63   * 
64   * you can also allocate a new direct buffer:
65   * 
66   * <pre>
67   * IoBuffer buf = IoBuffer.allocate(1024, true);
68   * </pre>
69   * 
70   * or you can set the default buffer type.
71   * 
72   * <pre>
73   * // Allocate heap buffer by default.
74   * IoBuffer.setUseDirectBuffer(false);
75   * // A new heap buffer is returned.
76   * IoBuffer buf = IoBuffer.allocate(1024);
77   * </pre>
78   * 
79   * </p>
80   * 
81   * <h2>Wrapping existing NIO buffers and arrays</h2>
82   * <p>
83   * This class provides a few <tt>wrap(...)</tt> methods that wraps any NIO
84   * buffers and byte arrays.
85   * 
86   * <h2>AutoExpand</h2>
87   * <p>
88   * Writing variable-length data using NIO <tt>ByteBuffers</tt> is not really
89   * easy, and it is because its size is fixed. {@link IoBuffer} introduces
90   * <tt>autoExpand</tt> property. If <tt>autoExpand</tt> property is true, you
91   * never get {@link BufferOverflowException} or
92   * {@link IndexOutOfBoundsException} (except when index is negative). It
93   * automatically expands its capacity and limit value. For example:
94   * 
95   * <pre>
96   * String greeting = messageBundle.getMessage(&quot;hello&quot;);
97   * IoBuffer buf = IoBuffer.allocate(16);
98   * // Turn on autoExpand (it is off by default)
99   * buf.setAutoExpand(true);
100  * buf.putString(greeting, utf8encoder);
101  * </pre>
102  * 
103  * The underlying {@link ByteBuffer} is reallocated by {@link IoBuffer} behind
104  * the scene if the encoded data is larger than 16 bytes in the example above.
105  * Its capacity will double, and its limit will increase to the last position
106  * the string is written.
107  * </p>
108  * 
109  * <h2>AutoShrink</h2>
110  * <p>
111  * You might also want to decrease the capacity of the buffer when most of the
112  * allocated memory area is not being used. {@link IoBuffer} provides
113  * <tt>autoShrink</tt> property to take care of this issue. If
114  * <tt>autoShrink</tt> is turned on, {@link IoBuffer} halves the capacity of the
115  * buffer when {@link #compact()} is invoked and only 1/4 or less of the current
116  * capacity is being used.
117  * <p>
118  * You can also {@link #shrink()} method manually to shrink the capacity of the
119  * buffer.
120  * <p>
121  * The underlying {@link ByteBuffer} is reallocated by {@link IoBuffer} behind
122  * the scene, and therefore {@link #buf()} will return a different
123  * {@link ByteBuffer} instance once capacity changes. Please also note
124  * {@link #compact()} or {@link #shrink()} will not decrease the capacity if the
125  * new capacity is less than the {@link #minimumCapacity()} of the buffer.
126  * 
127  * <h2>Derived Buffers</h2>
128  * <p>
129  * Derived buffers are the buffers which were created by {@link #duplicate()},
130  * {@link #slice()}, or {@link #asReadOnlyBuffer()}. They are useful especially
131  * when you broadcast the same messages to multiple {@link IoSession}s. Please
132  * note that the buffer derived from and its derived buffers are not both
133  * auto-expandable neither auto-shrinkable. Trying to call
134  * {@link #setAutoExpand(boolean)} or {@link #setAutoShrink(boolean)} with
135  * <tt>true</tt> parameter will raise an {@link IllegalStateException}.
136  * </p>
137  * 
138  * <h2>Changing Buffer Allocation Policy</h2>
139  * <p>
140  * {@link IoBufferAllocator} interface lets you override the default buffer
141  * management behavior. There are two allocators provided out-of-the-box:
142  * <ul>
143  * <li>{@link SimpleBufferAllocator} (default)</li>
144  * <li>{@link CachedBufferAllocator}</li>
145  * </ul>
146  * You can implement your own allocator and use it by calling
147  * {@link #setAllocator(IoBufferAllocator)}.
148  * </p>
149  * 
150  * @author <a href="http://mina.apache.org">Apache MINA Project</a>
151  */
152 public abstract class IoBuffer implements Comparable<IoBuffer> {
153     /** The allocator used to create new buffers */
154     private static IoBufferAllocator allocator = new SimpleBufferAllocator();
155 
156     /** A flag indicating which type of buffer we are using : heap or direct */
157     private static boolean useDirectBuffer = false;
158 
159     /**
160      * Returns the allocator used by existing and new buffers
161      */
162     public static IoBufferAllocator getAllocator() {
163         return allocator;
164     }
165 
166     /**
167      * Sets the allocator used by existing and new buffers
168      */
169     public static void setAllocator(IoBufferAllocator newAllocator) {
170         if (newAllocator == null) {
171             throw new IllegalArgumentException("allocator");
172         }
173 
174         IoBufferAllocator oldAllocator = allocator;
175 
176         allocator = newAllocator;
177 
178         if (null != oldAllocator) {
179             oldAllocator.dispose();
180         }
181     }
182 
183     /**
184      * Returns <tt>true</tt> if and only if a direct buffer is allocated by
185      * default when the type of the new buffer is not specified. The default
186      * value is <tt>false</tt>.
187      */
188     public static boolean isUseDirectBuffer() {
189         return useDirectBuffer;
190     }
191 
192     /**
193      * Sets if a direct buffer should be allocated by default when the type of
194      * the new buffer is not specified. The default value is <tt>false</tt>.
195      */
196     public static void setUseDirectBuffer(boolean useDirectBuffer) {
197         IoBuffer.useDirectBuffer = useDirectBuffer;
198     }
199 
200     /**
201      * Returns the direct or heap buffer which is capable to store the specified
202      * amount of bytes.
203      * 
204      * @param capacity
205      *            the capacity of the buffer
206      * 
207      * @see #setUseDirectBuffer(boolean)
208      */
209     public static IoBuffer allocate(int capacity) {
210         return allocate(capacity, useDirectBuffer);
211     }
212 
213     /**
214      * Returns the buffer which is capable of the specified size.
215      * 
216      * @param capacity
217      *            the capacity of the buffer
218      * @param direct
219      *            <tt>true</tt> to get a direct buffer, <tt>false</tt> to get a
220      *            heap buffer.
221      */
222     public static IoBuffer allocate(int capacity, boolean direct) {
223         if (capacity < 0) {
224             throw new IllegalArgumentException("capacity: " + capacity);
225         }
226 
227         return allocator.allocate(capacity, direct);
228     }
229 
230     /**
231      * Wraps the specified NIO {@link ByteBuffer} into MINA buffer.
232      */
233     public static IoBuffer wrap(ByteBuffer nioBuffer) {
234         return allocator.wrap(nioBuffer);
235     }
236 
237     /**
238      * Wraps the specified byte array into MINA heap buffer.
239      */
240     public static IoBuffer wrap(byte[] byteArray) {
241         return wrap(ByteBuffer.wrap(byteArray));
242     }
243 
244     /**
245      * Wraps the specified byte array into MINA heap buffer.
246      */
247     public static IoBuffer wrap(byte[] byteArray, int offset, int length) {
248         return wrap(ByteBuffer.wrap(byteArray, offset, length));
249     }
250 
251     /**
252      * Normalizes the specified capacity of the buffer to power of 2, which is
253      * often helpful for optimal memory usage and performance. If it is greater
254      * than or equal to {@link Integer#MAX_VALUE}, it returns
255      * {@link Integer#MAX_VALUE}. If it is zero, it returns zero.
256      */
257     protected static int normalizeCapacity(int requestedCapacity) {
258         if (requestedCapacity < 0) {
259             return Integer.MAX_VALUE;
260         }
261 
262         int newCapacity = Integer.highestOneBit(requestedCapacity);
263         newCapacity <<= (newCapacity < requestedCapacity ? 1 : 0);
264         return newCapacity < 0 ? Integer.MAX_VALUE : newCapacity;
265     }
266 
267     /**
268      * Creates a new instance. This is an empty constructor.
269      */
270     protected IoBuffer() {
271         // Do nothing
272     }
273 
274     /**
275      * Declares this buffer and all its derived buffers are not used anymore so
276      * that it can be reused by some {@link IoBufferAllocator} implementations.
277      * It is not mandatory to call this method, but you might want to invoke
278      * this method for maximum performance.
279      */
280     public abstract void free();
281 
282     /**
283      * Returns the underlying NIO buffer instance.
284      */
285     public abstract ByteBuffer buf();
286 
287     /**
288      * @see ByteBuffer#isDirect()
289      */
290     public abstract boolean isDirect();
291 
292     /**
293      * returns <tt>true</tt> if and only if this buffer is derived from other
294      * buffer via {@link #duplicate()}, {@link #slice()} or
295      * {@link #asReadOnlyBuffer()}.
296      */
297     public abstract boolean isDerived();
298 
299     /**
300      * @see ByteBuffer#isReadOnly()
301      */
302     public abstract boolean isReadOnly();
303 
304     /**
305      * Returns the minimum capacity of this buffer which is used to determine
306      * the new capacity of the buffer shrunk by {@link #compact()} and
307      * {@link #shrink()} operation. The default value is the initial capacity of
308      * the buffer.
309      */
310     public abstract int minimumCapacity();
311 
312     /**
313      * Sets the minimum capacity of this buffer which is used to determine the
314      * new capacity of the buffer shrunk by {@link #compact()} and
315      * {@link #shrink()} operation. The default value is the initial capacity of
316      * the buffer.
317      */
318     public abstract IoBuffer minimumCapacity(int minimumCapacity);
319 
320     /**
321      * @see ByteBuffer#capacity()
322      */
323     public abstract int capacity();
324 
325     /**
326      * Increases the capacity of this buffer. If the new capacity is less than
327      * or equal to the current capacity, this method returns silently. If the
328      * new capacity is greater than the current capacity, the buffer is
329      * reallocated while retaining the position, limit, mark and the content of
330      * the buffer.
331      */
332     public abstract IoBuffer capacity(int newCapacity);
333 
334     /**
335      * Returns <tt>true</tt> if and only if <tt>autoExpand</tt> is turned on.
336      */
337     public abstract boolean isAutoExpand();
338 
339     /**
340      * Turns on or off <tt>autoExpand</tt>.
341      */
342     public abstract IoBuffer setAutoExpand(boolean autoExpand);
343 
344     /**
345      * Returns <tt>true</tt> if and only if <tt>autoShrink</tt> is turned on.
346      */
347     public abstract boolean isAutoShrink();
348 
349     /**
350      * Turns on or off <tt>autoShrink</tt>.
351      */
352     public abstract IoBuffer setAutoShrink(boolean autoShrink);
353 
354     /**
355      * Changes the capacity and limit of this buffer so this buffer get the
356      * specified <tt>expectedRemaining</tt> room from the current position. This
357      * method works even if you didn't set <tt>autoExpand</tt> to <tt>true</tt>.
358      */
359     public abstract IoBuffer expand(int expectedRemaining);
360 
361     /**
362      * Changes the capacity and limit of this buffer so this buffer get the
363      * specified <tt>expectedRemaining</tt> room from the specified
364      * <tt>position</tt>. This method works even if you didn't set
365      * <tt>autoExpand</tt> to <tt>true</tt>.
366      */
367     public abstract IoBuffer expand(int position, int expectedRemaining);
368 
369     /**
370      * Changes the capacity of this buffer so this buffer occupies as less
371      * memory as possible while retaining the position, limit and the buffer
372      * content between the position and limit. The capacity of the buffer never
373      * becomes less than {@link #minimumCapacity()}. The mark is discarded once
374      * the capacity changes.
375      */
376     public abstract IoBuffer shrink();
377 
378     /**
379      * @see java.nio.Buffer#position()
380      */
381     public abstract int position();
382 
383     /**
384      * @see java.nio.Buffer#position(int)
385      */
386     public abstract IoBuffer position(int newPosition);
387 
388     /**
389      * @see java.nio.Buffer#limit()
390      */
391     public abstract int limit();
392 
393     /**
394      * @see java.nio.Buffer#limit(int)
395      */
396     public abstract IoBuffer limit(int newLimit);
397 
398     /**
399      * @see java.nio.Buffer#mark()
400      */
401     public abstract IoBuffer mark();
402 
403     /**
404      * Returns the position of the current mark. This method returns <tt>-1</tt>
405      * if no mark is set.
406      */
407     public abstract int markValue();
408 
409     /**
410      * @see java.nio.Buffer#reset()
411      */
412     public abstract IoBuffer reset();
413 
414     /**
415      * @see java.nio.Buffer#clear()
416      */
417     public abstract IoBuffer clear();
418 
419     /**
420      * Clears this buffer and fills its content with <tt>NUL</tt>. The position
421      * is set to zero, the limit is set to the capacity, and the mark is
422      * discarded.
423      */
424     public abstract IoBuffer sweep();
425 
426     /**
427      * double Clears this buffer and fills its content with <tt>value</tt>. The
428      * position is set to zero, the limit is set to the capacity, and the mark
429      * is discarded.
430      */
431     public abstract IoBuffer sweep(byte value);
432 
433     /**
434      * @see java.nio.Buffer#flip()
435      */
436     public abstract IoBuffer flip();
437 
438     /**
439      * @see java.nio.Buffer#rewind()
440      */
441     public abstract IoBuffer rewind();
442 
443     /**
444      * @see java.nio.Buffer#remaining()
445      */
446     public abstract int remaining();
447 
448     /**
449      * @see java.nio.Buffer#hasRemaining()
450      */
451     public abstract boolean hasRemaining();
452 
453     /**
454      * @see ByteBuffer#duplicate()
455      */
456     public abstract IoBuffer duplicate();
457 
458     /**
459      * @see ByteBuffer#slice()
460      */
461     public abstract IoBuffer slice();
462 
463     /**
464      * @see ByteBuffer#asReadOnlyBuffer()
465      */
466     public abstract IoBuffer asReadOnlyBuffer();
467 
468     /**
469      * @see ByteBuffer#hasArray()
470      */
471     public abstract boolean hasArray();
472 
473     /**
474      * @see ByteBuffer#array()
475      */
476     public abstract byte[] array();
477 
478     /**
479      * @see ByteBuffer#arrayOffset()
480      */
481     public abstract int arrayOffset();
482 
483     /**
484      * @see ByteBuffer#get()
485      */
486     public abstract byte get();
487 
488     /**
489      * Reads one unsigned byte as a short integer.
490      */
491     public abstract short getUnsigned();
492 
493     /**
494      * @see ByteBuffer#put(byte)
495      */
496     public abstract IoBuffer put(byte b);
497 
498     /**
499      * @see ByteBuffer#get(int)
500      */
501     public abstract byte get(int index);
502 
503     /**
504      * Reads one byte as an unsigned short integer.
505      */
506     public abstract short getUnsigned(int index);
507 
508     /**
509      * @see ByteBuffer#put(int, byte)
510      */
511     public abstract IoBuffer put(int index, byte b);
512 
513     /**
514      * @see ByteBuffer#get(byte[], int, int)
515      */
516     public abstract IoBuffer get(byte[] dst, int offset, int length);
517 
518     /**
519      * @see ByteBuffer#get(byte[])
520      */
521     public abstract IoBuffer get(byte[] dst);
522 
523     /**
524      * TODO document me.
525      */
526     public abstract IoBuffer getSlice(int index, int length);
527 
528     /**
529      * TODO document me.
530      */
531     public abstract IoBuffer getSlice(int length);
532 
533     /**
534      * Writes the content of the specified <tt>src</tt> into this buffer.
535      */
536     public abstract IoBuffer put(ByteBuffer src);
537 
538     /**
539      * Writes the content of the specified <tt>src</tt> into this buffer.
540      */
541     public abstract IoBuffer put(IoBuffer src);
542 
543     /**
544      * @see ByteBuffer#put(byte[], int, int)
545      */
546     public abstract IoBuffer put(byte[] src, int offset, int length);
547 
548     /**
549      * @see ByteBuffer#put(byte[])
550      */
551     public abstract IoBuffer put(byte[] src);
552 
553     /**
554      * @see ByteBuffer#compact()
555      */
556     public abstract IoBuffer compact();
557 
558     /**
559      * @see ByteBuffer#order()
560      */
561     public abstract ByteOrder order();
562 
563     /**
564      * @see ByteBuffer#order(ByteOrder)
565      */
566     public abstract IoBuffer order(ByteOrder bo);
567 
568     /**
569      * @see ByteBuffer#getChar()
570      */
571     public abstract char getChar();
572 
573     /**
574      * @see ByteBuffer#putChar(char)
575      */
576     public abstract IoBuffer putChar(char value);
577 
578     /**
579      * @see ByteBuffer#getChar(int)
580      */
581     public abstract char getChar(int index);
582 
583     /**
584      * @see ByteBuffer#putChar(int, char)
585      */
586     public abstract IoBuffer putChar(int index, char value);
587 
588     /**
589      * @see ByteBuffer#asCharBuffer()
590      */
591     public abstract CharBuffer asCharBuffer();
592 
593     /**
594      * @see ByteBuffer#getShort()
595      */
596     public abstract short getShort();
597 
598     /**
599      * Reads two bytes unsigned integer.
600      */
601     public abstract int getUnsignedShort();
602 
603     /**
604      * @see ByteBuffer#putShort(short)
605      */
606     public abstract IoBuffer putShort(short value);
607 
608     /**
609      * @see ByteBuffer#getShort()
610      */
611     public abstract short getShort(int index);
612 
613     /**
614      * Reads two bytes unsigned integer.
615      */
616     public abstract int getUnsignedShort(int index);
617 
618     /**
619      * @see ByteBuffer#putShort(int, short)
620      */
621     public abstract IoBuffer putShort(int index, short value);
622 
623     /**
624      * @see ByteBuffer#asShortBuffer()
625      */
626     public abstract ShortBuffer asShortBuffer();
627 
628     /**
629      * @see ByteBuffer#getInt()
630      */
631     public abstract int getInt();
632 
633     /**
634      * Reads four bytes unsigned integer.
635      */
636     public abstract long getUnsignedInt();
637 
638     /**
639      * Relative <i>get</i> method for reading a medium int value.
640      * 
641      * <p>
642      * Reads the next three bytes at this buffer's current position, composing
643      * them into an int value according to the current byte order, and then
644      * increments the position by three.
645      * </p>
646      * 
647      * @return The medium int value at the buffer's current position
648      */
649     public abstract int getMediumInt();
650 
651     /**
652      * Relative <i>get</i> method for reading an unsigned medium int value.
653      * 
654      * <p>
655      * Reads the next three bytes at this buffer's current position, composing
656      * them into an int value according to the current byte order, and then
657      * increments the position by three.
658      * </p>
659      * 
660      * @return The unsigned medium int value at the buffer's current position
661      */
662     public abstract int getUnsignedMediumInt();
663 
664     /**
665      * Absolute <i>get</i> method for reading a medium int value.
666      * 
667      * <p>
668      * Reads the next three bytes at this buffer's current position, composing
669      * them into an int value according to the current byte order.
670      * </p>
671      * 
672      * @param index
673      *            The index from which the medium int will be read
674      * @return The medium int value at the given index
675      * 
676      * @throws IndexOutOfBoundsException
677      *             If <tt>index</tt> is negative or not smaller than the
678      *             buffer's limit
679      */
680     public abstract int getMediumInt(int index);
681 
682     /**
683      * Absolute <i>get</i> method for reading an unsigned medium int value.
684      * 
685      * <p>
686      * Reads the next three bytes at this buffer's current position, composing
687      * them into an int value according to the current byte order.
688      * </p>
689      * 
690      * @param index
691      *            The index from which the unsigned medium int will be read
692      * @return The unsigned medium int value at the given index
693      * 
694      * @throws IndexOutOfBoundsException
695      *             If <tt>index</tt> is negative or not smaller than the
696      *             buffer's limit
697      */
698     public abstract int getUnsignedMediumInt(int index);
699 
700     /**
701      * Relative <i>put</i> method for writing a medium int value.
702      * 
703      * <p>
704      * Writes three bytes containing the given int value, in the current byte
705      * order, into this buffer at the current position, and then increments the
706      * position by three.
707      * </p>
708      * 
709      * @param value
710      *            The medium int value to be written
711      * 
712      * @return This buffer
713      * 
714      * @throws BufferOverflowException
715      *             If there are fewer than three bytes remaining in this buffer
716      * 
717      * @throws ReadOnlyBufferException
718      *             If this buffer is read-only
719      */
720     public abstract IoBuffer putMediumInt(int value);
721 
722     /**
723      * Absolute <i>put</i> method for writing a medium int value.
724      * 
725      * <p>
726      * Writes three bytes containing the given int value, in the current byte
727      * order, into this buffer at the given index.
728      * </p>
729      * 
730      * @param index
731      *            The index at which the bytes will be written
732      * 
733      * @param value
734      *            The medium int value to be written
735      * 
736      * @return This buffer
737      * 
738      * @throws IndexOutOfBoundsException
739      *             If <tt>index</tt> is negative or not smaller than the
740      *             buffer's limit, minus three
741      * 
742      * @throws ReadOnlyBufferException
743      *             If this buffer is read-only
744      */
745     public abstract IoBuffer putMediumInt(int index, int value);
746 
747     /**
748      * @see ByteBuffer#putInt(int)
749      */
750     public abstract IoBuffer putInt(int value);
751 
752     /**
753      * Writes an unsigned byte into the ByteBuffer
754      * @param value the byte to write
755      */
756     public abstract IoBuffer putUnsigned(byte value);
757 
758     /**
759      * Writes an unsigned byte into the ByteBuffer at a specified position
760      * @param index the position in the buffer to write the value
761      * @param value the byte to write
762      */
763     public abstract IoBuffer putUnsigned(int index, byte value);
764 
765     /**
766      * Writes an unsigned byte into the ByteBuffer
767      * @param value the short to write
768      */
769     public abstract IoBuffer putUnsigned(short value);
770 
771     /**
772      * Writes an unsigned byte into the ByteBuffer at a specified position
773      * @param index the position in the buffer to write the value
774      * @param value the short to write
775      */
776     public abstract IoBuffer putUnsigned(int index, short value);
777 
778     /**
779      * Writes an unsigned byte into the ByteBuffer
780      * @param value the int to write
781      */
782     public abstract IoBuffer putUnsigned(int value);
783 
784     /**
785      * Writes an unsigned byte into the ByteBuffer at a specified position
786      * @param index the position in the buffer to write the value
787      * @param value the int to write
788      */
789     public abstract IoBuffer putUnsigned(int index, int value);
790 
791     /**
792      * Writes an unsigned byte into the ByteBuffer
793      * @param value the long to write
794      */
795     public abstract IoBuffer putUnsigned(long value);
796 
797     /**
798      * Writes an unsigned byte into the ByteBuffer at a specified position
799      * @param index the position in the buffer to write the value
800      * @param value the long to write
801      */
802     public abstract IoBuffer putUnsigned(int index, long value);
803 
804     /**
805      * Writes an unsigned int into the ByteBuffer
806      * @param value the byte to write
807      */
808     public abstract IoBuffer putUnsignedInt(byte value);
809 
810     /**
811      * Writes an unsigned int into the ByteBuffer at a specified position
812      * @param index the position in the buffer to write the value
813      * @param value the byte to write
814      */
815     public abstract IoBuffer putUnsignedInt(int index, byte value);
816 
817     /**
818      * Writes an unsigned int into the ByteBuffer
819      * @param value the short to write
820      */
821     public abstract IoBuffer putUnsignedInt(short value);
822 
823     /**
824      * Writes an unsigned int into the ByteBuffer at a specified position
825      * @param index the position in the buffer to write the value
826      * @param value the short to write
827      */
828     public abstract IoBuffer putUnsignedInt(int index, short value);
829 
830     /**
831      * Writes an unsigned int into the ByteBuffer
832      * @param value the int to write
833      */
834     public abstract IoBuffer putUnsignedInt(int value);
835 
836     /**
837      * Writes an unsigned int into the ByteBuffer at a specified position
838      * @param index the position in the buffer to write the value
839      * @param value the int to write
840      */
841     public abstract IoBuffer putUnsignedInt(int index, int value);
842 
843     /**
844      * Writes an unsigned int into the ByteBuffer
845      * @param value the long to write
846      */
847     public abstract IoBuffer putUnsignedInt(long value);
848 
849     /**
850      * Writes an unsigned int into the ByteBuffer at a specified position
851      * @param index the position in the buffer to write the value
852      * @param value the long to write
853      */
854     public abstract IoBuffer putUnsignedInt(int index, long value);
855 
856     /**
857      * Writes an unsigned short into the ByteBuffer
858      * @param value the byte to write
859      */
860     public abstract IoBuffer putUnsignedShort(byte value);
861 
862     /**
863      * Writes an unsigned Short into the ByteBuffer at a specified position
864      * @param index the position in the buffer to write the value
865      * @param value the byte to write
866      */
867     public abstract IoBuffer putUnsignedShort(int index, byte value);
868 
869     /**
870      * Writes an unsigned Short into the ByteBuffer
871      * @param value the short to write
872      */
873     public abstract IoBuffer putUnsignedShort(short value);
874 
875     /**
876      * Writes an unsigned Short into the ByteBuffer at a specified position
877      * @param index the position in the buffer to write the value
878      * @param value the short to write
879      */
880     public abstract IoBuffer putUnsignedShort(int index, short value);
881 
882     /**
883      * Writes an unsigned Short into the ByteBuffer
884      * @param value the int to write
885      */
886     public abstract IoBuffer putUnsignedShort(int value);
887 
888     /**
889      * Writes an unsigned Short into the ByteBuffer at a specified position
890      * @param index the position in the buffer to write the value
891      * @param value the int to write
892      */
893     public abstract IoBuffer putUnsignedShort(int index, int value);
894 
895     /**
896      * Writes an unsigned Short into the ByteBuffer
897      * @param value the long to write
898      */
899     public abstract IoBuffer putUnsignedShort(long value);
900 
901     /**
902      * Writes an unsigned Short into the ByteBuffer at a specified position
903      * @param index the position in the buffer to write the value
904      * @param value the long to write
905      */
906     public abstract IoBuffer putUnsignedShort(int index, long value);
907 
908     /**
909      * @see ByteBuffer#getInt(int)
910      */
911     public abstract int getInt(int index);
912 
913     /**
914      * Reads four bytes unsigned integer.
915      * @param index the position in the buffer to write the value
916      */
917     public abstract long getUnsignedInt(int index);
918 
919     /**
920      * @see ByteBuffer#putInt(int, int)
921      */
922     public abstract IoBuffer putInt(int index, int value);
923 
924     /**
925      * @see ByteBuffer#asIntBuffer()
926      */
927     public abstract IntBuffer asIntBuffer();
928 
929     /**
930      * @see ByteBuffer#getLong()
931      */
932     public abstract long getLong();
933 
934     /**
935      * @see ByteBuffer#putLong(int, long)
936      */
937     public abstract IoBuffer putLong(long value);
938 
939     /**
940      * @see ByteBuffer#getLong(int)
941      */
942     public abstract long getLong(int index);
943 
944     /**
945      * @see ByteBuffer#putLong(int, long)
946      */
947     public abstract IoBuffer putLong(int index, long value);
948 
949     /**
950      * @see ByteBuffer#asLongBuffer()
951      */
952     public abstract LongBuffer asLongBuffer();
953 
954     /**
955      * @see ByteBuffer#getFloat()
956      */
957     public abstract float getFloat();
958 
959     /**
960      * @see ByteBuffer#putFloat(float)
961      */
962     public abstract IoBuffer putFloat(float value);
963 
964     /**
965      * @see ByteBuffer#getFloat(int)
966      */
967     public abstract float getFloat(int index);
968 
969     /**
970      * @see ByteBuffer#putFloat(int, float)
971      */
972     public abstract IoBuffer putFloat(int index, float value);
973 
974     /**
975      * @see ByteBuffer#asFloatBuffer()
976      */
977     public abstract FloatBuffer asFloatBuffer();
978 
979     /**
980      * @see ByteBuffer#getDouble()
981      */
982     public abstract double getDouble();
983 
984     /**
985      * @see ByteBuffer#putDouble(double)
986      */
987     public abstract IoBuffer putDouble(double value);
988 
989     /**
990      * @see ByteBuffer#getDouble(int)
991      */
992     public abstract double getDouble(int index);
993 
994     /**
995      * @see ByteBuffer#putDouble(int, double)
996      */
997     public abstract IoBuffer putDouble(int index, double value);
998 
999     /**
1000      * @see ByteBuffer#asDoubleBuffer()
1001      */
1002     public abstract DoubleBuffer asDoubleBuffer();
1003 
1004     /**
1005      * Returns an {@link InputStream} that reads the data from this buffer.
1006      * {@link InputStream#read()} returns <tt>-1</tt> if the buffer position
1007      * reaches to the limit.
1008      */
1009     public abstract InputStream asInputStream();
1010 
1011     /**
1012      * Returns an {@link OutputStream} that appends the data into this buffer.
1013      * Please note that the {@link OutputStream#write(int)} will throw a
1014      * {@link BufferOverflowException} instead of an {@link IOException} in case
1015      * of buffer overflow. Please set <tt>autoExpand</tt> property by calling
1016      * {@link #setAutoExpand(boolean)} to prevent the unexpected runtime
1017      * exception.
1018      */
1019     public abstract OutputStream asOutputStream();
1020 
1021     /**
1022      * Returns hexdump of this buffer. The data and pointer are not changed as a
1023      * result of this method call.
1024      * 
1025      * @return hexidecimal representation of this buffer
1026      */
1027     public abstract String getHexDump();
1028 
1029     /**
1030      * Return hexdump of this buffer with limited length.
1031      * 
1032      * @param lengthLimit
1033      *            The maximum number of bytes to dump from the current buffer
1034      *            position.
1035      * @return hexidecimal representation of this buffer
1036      */
1037     public abstract String getHexDump(int lengthLimit);
1038 
1039     // //////////////////////////////
1040     // String getters and putters //
1041     // //////////////////////////////
1042 
1043     /**
1044      * Reads a <code>NUL</code>-terminated string from this buffer using the
1045      * specified <code>decoder</code> and returns it. This method reads until
1046      * the limit of this buffer if no <tt>NUL</tt> is found.
1047      */
1048     public abstract String getString(CharsetDecoder decoder) throws CharacterCodingException;
1049 
1050     /**
1051      * Reads a <code>NUL</code>-terminated string from this buffer using the
1052      * specified <code>decoder</code> and returns it.
1053      * 
1054      * @param fieldSize
1055      *            the maximum number of bytes to read
1056      */
1057     public abstract String getString(int fieldSize, CharsetDecoder decoder) throws CharacterCodingException;
1058 
1059     /**
1060      * Writes the content of <code>in</code> into this buffer using the
1061      * specified <code>encoder</code>. This method doesn't terminate string with
1062      * <tt>NUL</tt>. You have to do it by yourself.
1063      * 
1064      * @throws BufferOverflowException
1065      *             if the specified string doesn't fit
1066      */
1067     public abstract IoBuffer putString(CharSequence val, CharsetEncoder encoder) throws CharacterCodingException;
1068 
1069     /**
1070      * Writes the content of <code>in</code> into this buffer as a
1071      * <code>NUL</code>-terminated string using the specified
1072      * <code>encoder</code>.
1073      * <p>
1074      * If the charset name of the encoder is UTF-16, you cannot specify odd
1075      * <code>fieldSize</code>, and this method will append two <code>NUL</code>s
1076      * as a terminator.
1077      * <p>
1078      * Please note that this method doesn't terminate with <code>NUL</code> if
1079      * the input string is longer than <tt>fieldSize</tt>.
1080      * 
1081      * @param fieldSize
1082      *            the maximum number of bytes to write
1083      */
1084     public abstract IoBuffer putString(CharSequence val, int fieldSize, CharsetEncoder encoder)
1085             throws CharacterCodingException;
1086 
1087     /**
1088      * Reads a string which has a 16-bit length field before the actual encoded
1089      * string, using the specified <code>decoder</code> and returns it. This
1090      * method is a shortcut for <tt>getPrefixedString(2, decoder)</tt>.
1091      */
1092     public abstract String getPrefixedString(CharsetDecoder decoder) throws CharacterCodingException;
1093 
1094     /**
1095      * Reads a string which has a length field before the actual encoded string,
1096      * using the specified <code>decoder</code> and returns it.
1097      * 
1098      * @param prefixLength
1099      *            the length of the length field (1, 2, or 4)
1100      */
1101     public abstract String getPrefixedString(int prefixLength, CharsetDecoder decoder) throws CharacterCodingException;
1102 
1103     /**
1104      * Writes the content of <code>in</code> into this buffer as a string which
1105      * has a 16-bit length field before the actual encoded string, using the
1106      * specified <code>encoder</code>. This method is a shortcut for
1107      * <tt>putPrefixedString(in, 2, 0, encoder)</tt>.
1108      * 
1109      * @throws BufferOverflowException
1110      *             if the specified string doesn't fit
1111      */
1112     public abstract IoBuffer putPrefixedString(CharSequence in, CharsetEncoder encoder) throws CharacterCodingException;
1113 
1114     /**
1115      * Writes the content of <code>in</code> into this buffer as a string which
1116      * has a 16-bit length field before the actual encoded string, using the
1117      * specified <code>encoder</code>. This method is a shortcut for
1118      * <tt>putPrefixedString(in, prefixLength, 0, encoder)</tt>.
1119      * 
1120      * @param prefixLength
1121      *            the length of the length field (1, 2, or 4)
1122      * 
1123      * @throws BufferOverflowException
1124      *             if the specified string doesn't fit
1125      */
1126     public abstract IoBuffer putPrefixedString(CharSequence in, int prefixLength, CharsetEncoder encoder)
1127             throws CharacterCodingException;
1128 
1129     /**
1130      * Writes the content of <code>in</code> into this buffer as a string which
1131      * has a 16-bit length field before the actual encoded string, using the
1132      * specified <code>encoder</code>. This method is a shortcut for
1133      * <tt>putPrefixedString(in, prefixLength, padding, ( byte ) 0, encoder)</tt>
1134      * .
1135      * 
1136      * @param prefixLength
1137      *            the length of the length field (1, 2, or 4)
1138      * @param padding
1139      *            the number of padded <tt>NUL</tt>s (1 (or 0), 2, or 4)
1140      * 
1141      * @throws BufferOverflowException
1142      *             if the specified string doesn't fit
1143      */
1144     public abstract IoBuffer putPrefixedString(CharSequence in, int prefixLength, int padding, CharsetEncoder encoder)
1145             throws CharacterCodingException;
1146 
1147     /**
1148      * Writes the content of <code>in</code> into this buffer as a string which
1149      * has a 16-bit length field before the actual encoded string, using the
1150      * specified <code>encoder</code>.
1151      * 
1152      * @param prefixLength
1153      *            the length of the length field (1, 2, or 4)
1154      * @param padding
1155      *            the number of padded bytes (1 (or 0), 2, or 4)
1156      * @param padValue
1157      *            the value of padded bytes
1158      * 
1159      * @throws BufferOverflowException
1160      *             if the specified string doesn't fit
1161      */
1162     public abstract IoBuffer putPrefixedString(CharSequence val, int prefixLength, int padding, byte padValue,
1163             CharsetEncoder encoder) throws CharacterCodingException;
1164 
1165     /**
1166      * Reads a Java object from the buffer using the context {@link ClassLoader}
1167      * of the current thread.
1168      */
1169     public abstract Object getObject() throws ClassNotFoundException;
1170 
1171     /**
1172      * Reads a Java object from the buffer using the specified
1173      * <tt>classLoader</tt>.
1174      */
1175     public abstract Object getObject(final ClassLoader classLoader) throws ClassNotFoundException;
1176 
1177     /**
1178      * Writes the specified Java object to the buffer.
1179      */
1180     public abstract IoBuffer putObject(Object o);
1181 
1182     /**
1183      * Returns <tt>true</tt> if this buffer contains a data which has a data
1184      * length as a prefix and the buffer has remaining data as enough as
1185      * specified in the data length field. This method is identical with
1186      * <tt>prefixedDataAvailable( prefixLength, Integer.MAX_VALUE )</tt>. Please
1187      * not that using this method can allow DoS (Denial of Service) attack in
1188      * case the remote peer sends too big data length value. It is recommended
1189      * to use {@link #prefixedDataAvailable(int, int)} instead.
1190      * 
1191      * @param prefixLength
1192      *            the length of the prefix field (1, 2, or 4)
1193      * 
1194      * @throws IllegalArgumentException
1195      *             if prefixLength is wrong
1196      * @throws BufferDataException
1197      *             if data length is negative
1198      */
1199     public abstract boolean prefixedDataAvailable(int prefixLength);
1200 
1201     /**
1202      * Returns <tt>true</tt> if this buffer contains a data which has a data
1203      * length as a prefix and the buffer has remaining data as enough as
1204      * specified in the data length field.
1205      * 
1206      * @param prefixLength
1207      *            the length of the prefix field (1, 2, or 4)
1208      * @param maxDataLength
1209      *            the allowed maximum of the read data length
1210      * 
1211      * @throws IllegalArgumentException
1212      *             if prefixLength is wrong
1213      * @throws BufferDataException
1214      *             if data length is negative or greater then
1215      *             <tt>maxDataLength</tt>
1216      */
1217     public abstract boolean prefixedDataAvailable(int prefixLength, int maxDataLength);
1218 
1219     // ///////////////////
1220     // IndexOf methods //
1221     // ///////////////////
1222 
1223     /**
1224      * Returns the first occurence position of the specified byte from the
1225      * current position to the current limit.
1226      * 
1227      * @return <tt>-1</tt> if the specified byte is not found
1228      */
1229     public abstract int indexOf(byte b);
1230 
1231     // ////////////////////////
1232     // Skip or fill methods //
1233     // ////////////////////////
1234 
1235     /**
1236      * Forwards the position of this buffer as the specified <code>size</code>
1237      * bytes.
1238      */
1239     public abstract IoBuffer skip(int size);
1240 
1241     /**
1242      * Fills this buffer with the specified value. This method moves buffer
1243      * position forward.
1244      */
1245     public abstract IoBuffer fill(byte value, int size);
1246 
1247     /**
1248      * Fills this buffer with the specified value. This method does not change
1249      * buffer position.
1250      */
1251     public abstract IoBuffer fillAndReset(byte value, int size);
1252 
1253     /**
1254      * Fills this buffer with <code>NUL (0x00)</code>. This method moves buffer
1255      * position forward.
1256      */
1257     public abstract IoBuffer fill(int size);
1258 
1259     /**
1260      * Fills this buffer with <code>NUL (0x00)</code>. This method does not
1261      * change buffer position.
1262      */
1263     public abstract IoBuffer fillAndReset(int size);
1264 
1265     // ////////////////////////
1266     // Enum methods //
1267     // ////////////////////////
1268 
1269     /**
1270      * Reads a byte from the buffer and returns the correlating enum constant
1271      * defined by the specified enum type.
1272      * 
1273      * @param <E>
1274      *            The enum type to return
1275      * @param enumClass
1276      *            The enum's class object
1277      */
1278     public abstract <E extends Enum<E>> E getEnum(Class<E> enumClass);
1279 
1280     /**
1281      * Reads a byte from the buffer and returns the correlating enum constant
1282      * defined by the specified enum type.
1283      * 
1284      * @param <E>
1285      *            The enum type to return
1286      * @param index
1287      *            the index from which the byte will be read
1288      * @param enumClass
1289      *            The enum's class object
1290      */
1291     public abstract <E extends Enum<E>> E getEnum(int index, Class<E> enumClass);
1292 
1293     /**
1294      * Reads a short from the buffer and returns the correlating enum constant
1295      * defined by the specified enum type.
1296      * 
1297      * @param <E>
1298      *            The enum type to return
1299      * @param enumClass
1300      *            The enum's class object
1301      */
1302     public abstract <E extends Enum<E>> E getEnumShort(Class<E> enumClass);
1303 
1304     /**
1305      * Reads a short from the buffer and returns the correlating enum constant
1306      * defined by the specified enum type.
1307      * 
1308      * @param <E>
1309      *            The enum type to return
1310      * @param index
1311      *            the index from which the bytes will be read
1312      * @param enumClass
1313      *            The enum's class object
1314      */
1315     public abstract <E extends Enum<E>> E getEnumShort(int index, Class<E> enumClass);
1316 
1317     /**
1318      * Reads an int from the buffer and returns the correlating enum constant
1319      * defined by the specified enum type.
1320      * 
1321      * @param <E>
1322      *            The enum type to return
1323      * @param enumClass
1324      *            The enum's class object
1325      */
1326     public abstract <E extends Enum<E>> E getEnumInt(Class<E> enumClass);
1327 
1328     /**
1329      * Reads an int from the buffer and returns the correlating enum constant
1330      * defined by the specified enum type.
1331      * 
1332      * @param <E>
1333      *            The enum type to return
1334      * @param index
1335      *            the index from which the bytes will be read
1336      * @param enumClass
1337      *            The enum's class object
1338      */
1339     public abstract <E extends Enum<E>> E getEnumInt(int index, Class<E> enumClass);
1340 
1341     /**
1342      * Writes an enum's ordinal value to the buffer as a byte.
1343      * 
1344      * @param e
1345      *            The enum to write to the buffer
1346      */
1347     public abstract IoBuffer putEnum(Enum<?> e);
1348 
1349     /**
1350      * Writes an enum's ordinal value to the buffer as a byte.
1351      * 
1352      * @param index
1353      *            The index at which the byte will be written
1354      * @param e
1355      *            The enum to write to the buffer
1356      */
1357     public abstract IoBuffer putEnum(int index, Enum<?> e);
1358 
1359     /**
1360      * Writes an enum's ordinal value to the buffer as a short.
1361      * 
1362      * @param e
1363      *            The enum to write to the buffer
1364      */
1365     public abstract IoBuffer putEnumShort(Enum<?> e);
1366 
1367     /**
1368      * Writes an enum's ordinal value to the buffer as a short.
1369      * 
1370      * @param index
1371      *            The index at which the bytes will be written
1372      * @param e
1373      *            The enum to write to the buffer
1374      */
1375     public abstract IoBuffer putEnumShort(int index, Enum<?> e);
1376 
1377     /**
1378      * Writes an enum's ordinal value to the buffer as an integer.
1379      * 
1380      * @param e
1381      *            The enum to write to the buffer
1382      */
1383     public abstract IoBuffer putEnumInt(Enum<?> e);
1384 
1385     /**
1386      * Writes an enum's ordinal value to the buffer as an integer.
1387      * 
1388      * @param index
1389      *            The index at which the bytes will be written
1390      * @param e
1391      *            The enum to write to the buffer
1392      */
1393     public abstract IoBuffer putEnumInt(int index, Enum<?> e);
1394 
1395     // ////////////////////////
1396     // EnumSet methods //
1397     // ////////////////////////
1398 
1399     /**
1400      * Reads a byte sized bit vector and converts it to an {@link EnumSet}.
1401      * 
1402      * <p>
1403      * Each bit is mapped to a value in the specified enum. The least
1404      * significant bit maps to the first entry in the specified enum and each
1405      * subsequent bit maps to each subsequent bit as mapped to the subsequent
1406      * enum value.
1407      * </p>
1408      * 
1409      * @param <E>
1410      *            the enum type
1411      * @param enumClass
1412      *            the enum class used to create the EnumSet
1413      * @return the EnumSet representation of the bit vector
1414      */
1415     public abstract <E extends Enum<E>> EnumSet<E> getEnumSet(Class<E> enumClass);
1416 
1417     /**
1418      * Reads a byte sized bit vector and converts it to an {@link EnumSet}.
1419      * 
1420      * @see #getEnumSet(Class)
1421      * @param <E>
1422      *            the enum type
1423      * @param index
1424      *            the index from which the byte will be read
1425      * @param enumClass
1426      *            the enum class used to create the EnumSet
1427      * @return the EnumSet representation of the bit vector
1428      */
1429     public abstract <E extends Enum<E>> EnumSet<E> getEnumSet(int index, Class<E> enumClass);
1430 
1431     /**
1432      * Reads a short sized bit vector and converts it to an {@link EnumSet}.
1433      * 
1434      * @see #getEnumSet(Class)
1435      * @param <E>
1436      *            the enum type
1437      * @param enumClass
1438      *            the enum class used to create the EnumSet
1439      * @return the EnumSet representation of the bit vector
1440      */
1441     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetShort(Class<E> enumClass);
1442 
1443     /**
1444      * Reads a short sized bit vector and converts it to an {@link EnumSet}.
1445      * 
1446      * @see #getEnumSet(Class)
1447      * @param <E>
1448      *            the enum type
1449      * @param index
1450      *            the index from which the bytes will be read
1451      * @param enumClass
1452      *            the enum class used to create the EnumSet
1453      * @return the EnumSet representation of the bit vector
1454      */
1455     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetShort(int index, Class<E> enumClass);
1456 
1457     /**
1458      * Reads an int sized bit vector and converts it to an {@link EnumSet}.
1459      * 
1460      * @see #getEnumSet(Class)
1461      * @param <E>
1462      *            the enum type
1463      * @param enumClass
1464      *            the enum class used to create the EnumSet
1465      * @return the EnumSet representation of the bit vector
1466      */
1467     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetInt(Class<E> enumClass);
1468 
1469     /**
1470      * Reads an int sized bit vector and converts it to an {@link EnumSet}.
1471      * 
1472      * @see #getEnumSet(Class)
1473      * @param <E>
1474      *            the enum type
1475      * @param index
1476      *            the index from which the bytes will be read
1477      * @param enumClass
1478      *            the enum class used to create the EnumSet
1479      * @return the EnumSet representation of the bit vector
1480      */
1481     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetInt(int index, Class<E> enumClass);
1482 
1483     /**
1484      * Reads a long sized bit vector and converts it to an {@link EnumSet}.
1485      * 
1486      * @see #getEnumSet(Class)
1487      * @param <E>
1488      *            the enum type
1489      * @param enumClass
1490      *            the enum class used to create the EnumSet
1491      * @return the EnumSet representation of the bit vector
1492      */
1493     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetLong(Class<E> enumClass);
1494 
1495     /**
1496      * Reads a long sized bit vector and converts it to an {@link EnumSet}.
1497      * 
1498      * @see #getEnumSet(Class)
1499      * @param <E>
1500      *            the enum type
1501      * @param index
1502      *            the index from which the bytes will be read
1503      * @param enumClass
1504      *            the enum class used to create the EnumSet
1505      * @return the EnumSet representation of the bit vector
1506      */
1507     public abstract <E extends Enum<E>> EnumSet<E> getEnumSetLong(int index, Class<E> enumClass);
1508 
1509     /**
1510      * Writes the specified {@link Set} to the buffer as a byte sized bit
1511      * vector.
1512      * 
1513      * @param <E>
1514      *            the enum type of the Set
1515      * @param set
1516      *            the enum set to write to the buffer
1517      */
1518     public abstract <E extends Enum<E>> IoBuffer putEnumSet(Set<E> set);
1519 
1520     /**
1521      * Writes the specified {@link Set} to the buffer as a byte sized bit
1522      * vector.
1523      * 
1524      * @param <E>
1525      *            the enum type of the Set
1526      * @param index
1527      *            the index at which the byte will be written
1528      * @param set
1529      *            the enum set to write to the buffer
1530      */
1531     public abstract <E extends Enum<E>> IoBuffer putEnumSet(int index, Set<E> set);
1532 
1533     /**
1534      * Writes the specified {@link Set} to the buffer as a short sized bit
1535      * vector.
1536      * 
1537      * @param <E>
1538      *            the enum type of the Set
1539      * @param set
1540      *            the enum set to write to the buffer
1541      */
1542     public abstract <E extends Enum<E>> IoBuffer putEnumSetShort(Set<E> set);
1543 
1544     /**
1545      * Writes the specified {@link Set} to the buffer as a short sized bit
1546      * vector.
1547      * 
1548      * @param <E>
1549      *            the enum type of the Set
1550      * @param index
1551      *            the index at which the bytes will be written
1552      * @param set
1553      *            the enum set to write to the buffer
1554      */
1555     public abstract <E extends Enum<E>> IoBuffer putEnumSetShort(int index, Set<E> set);
1556 
1557     /**
1558      * Writes the specified {@link Set} to the buffer as an int sized bit
1559      * vector.
1560      * 
1561      * @param <E>
1562      *            the enum type of the Set
1563      * @param set
1564      *            the enum set to write to the buffer
1565      */
1566     public abstract <E extends Enum<E>> IoBuffer putEnumSetInt(Set<E> set);
1567 
1568     /**
1569      * Writes the specified {@link Set} to the buffer as an int sized bit
1570      * vector.
1571      * 
1572      * @param <E>
1573      *            the enum type of the Set
1574      * @param index
1575      *            the index at which the bytes will be written
1576      * @param set
1577      *            the enum set to write to the buffer
1578      */
1579     public abstract <E extends Enum<E>> IoBuffer putEnumSetInt(int index, Set<E> set);
1580 
1581     /**
1582      * Writes the specified {@link Set} to the buffer as a long sized bit
1583      * vector.
1584      * 
1585      * @param <E>
1586      *            the enum type of the Set
1587      * @param set
1588      *            the enum set to write to the buffer
1589      */
1590     public abstract <E extends Enum<E>> IoBuffer putEnumSetLong(Set<E> set);
1591 
1592     /**
1593      * Writes the specified {@link Set} to the buffer as a long sized bit
1594      * vector.
1595      * 
1596      * @param <E>
1597      *            the enum type of the Set
1598      * @param index
1599      *            the index at which the bytes will be written
1600      * @param set
1601      *            the enum set to write to the buffer
1602      */
1603     public abstract <E extends Enum<E>> IoBuffer putEnumSetLong(int index, Set<E> set);
1604 }