KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > imagero > uio > buffer > arrays > CharArrayBufferManager


1 /*
2  * Copyright (c) Andrey Kuznetsov. All Rights Reserved.
3  *
4  * http://uio.imagero.com
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * o Redistributions of source code must retain the above copyright notice,
10  * this list of conditions and the following disclaimer.
11  *
12  * o Redistributions in binary form must reproduce the above copyright notice,
13  * this list of conditions and the following disclaimer in the documentation
14  * and/or other materials provided with the distribution.
15  *
16  * o Neither the name of imagero Andrei Kouznetsov nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 package com.imagero.uio.buffer.arrays;
33
34 import com.imagero.uio.buffer.MemoryAccessManager;
35
36
37 /**
38  * Gives possibility to read and write a short array using RandomAccess interface
39  *
40  * @author Andrei Kouznetsov
41  * Date: 01.06.2004
42  * Time: 22:35:58
43  */
44 public class CharArrayBufferManager extends AbstractArrayBufferManager {
45
46     char[] data;
47
48     /**
49      * Create ShortArrayBufferManager with standard tile size
50      *
51      * @param data int array
52      */
53     public CharArrayBufferManager(char[] data) {
54         this(data, Math.min(TILE_SIZE, data.length));
55     }
56
57     /**
58      * @param data int array
59      * @param size tile length (for Buffer)
60      */
61     public CharArrayBufferManager(char[] data, int size) {
62         this(data, 0, data.length, size);
63     }
64
65     /**
66      * @param data int array
67      * @param offset start offset in <code>data</code>
68      * @param length length to read
69      */
70     public CharArrayBufferManager(char[] data, int offset, int length) {
71         this(data, offset, length, TILE_SIZE);
72     }
73
74     /**
75      * @param data int array
76      * @param offset start offset in <code>data</code>
77      * @param length length to read
78      * @param size tile length (for Buffer)
79      */
80     public CharArrayBufferManager(char[] data, int offset, int length, int size) {
81         this.data = data;
82         this.tileSize = size;
83         this.unitSize = 2;
84         this.length = length;
85         this.offset = offset;
86         accessManager = MemoryAccessManager.createMemoryAccessManager();
87     }
88
89     /**
90      * write appropriate unit (int) in LITTLE_ENDIAN order
91      *
92      * @param source source byte array
93      * @param sourceOffset offset in source array
94      * @param destOffset offset in destination array
95      *
96      * @return new offset in source array (for next writeUnitXX)
97      */
98     protected int writeUnitLE(byte[] source, int sourceOffset, int destOffset) {
99         int v = ((source[sourceOffset++] & 0xFF))
100                 | (((source[sourceOffset++] & 0xFF)) << 8);
101         data[destOffset] = (char) v;
102         return sourceOffset;
103     }
104
105     /**
106      * write appropriate unit (int) in BIG_ENDIAN order
107      *
108      * @param source source byte array
109      * @param sourceOffset offset in source array
110      * @param destOffset offset in destination array
111      *
112      * @return new offset in source array (for next writeUnitXX)
113      */
114     protected int writeUnitBE(byte[] source, int sourceOffset, int destOffset) {
115         int v = ((source[sourceOffset++] & 0xFF) << 8)
116                 | (source[sourceOffset++] & 0xFF);
117         data[destOffset] = (char) v;
118         return sourceOffset;
119     }
120
121     /**
122      * read unit (short) in BIG_ENDIAN order
123      *
124      * @param offset offset in source array
125      * @param dest byte array (destination)
126      * @param destOffset offset in destination array
127      *
128      * @return offset in destination array (updated)
129      */
130     protected int readUnitBE(int offset, byte[] dest, int destOffset) {
131         int v = data[offset];
132         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
133         dest[destOffset++] = (byte) (v & 0xFF);
134         return destOffset;
135     }
136
137     /**
138      * read appropriate unit (short) in LITTLE_ENDIAN order
139      *
140      * @param offset offset in source array
141      * @param dest byte array (destination)
142      * @param destOffset offset in destination array
143      *
144      * @return offset in destination array (updated)
145      */
146     protected int readUnitLE(int offset, byte[] dest, int destOffset) {
147         int v = data[offset];
148         dest[destOffset++] = (byte) (v & 0xFF);
149         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
150         return destOffset;
151     }
152 }
153
Popular Tags