001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: /**
018: * @author Sergey V. Kuksenko
019: * @version $Revision$
020: */package org.apache.harmony.awt.nativebridge;
021:
022: /**
023: *
024: * TODO: implement char array support
025: */
026: public class Int16Pointer extends VoidPointer {
027:
028: private static final int INT16_SIZE_FACTOR = 2;
029:
030: //-- TODO: char array support is unimplemented yet
031: private char[] array;
032: private int offset;
033:
034: Int16Pointer(long addr) {
035: super (addr);
036: }
037:
038: Int16Pointer(int size, boolean direct) {
039: super (size * INT16_SIZE_FACTOR, direct);
040: }
041:
042: Int16Pointer(ByteBase base) {
043: super (base);
044: }
045:
046: // Int16Pointer(char[] arr) {
047: // this(arr, 0, arr.length);
048: // }
049: //
050: // Int16Pointer(char[] arr, int offset, int size) {
051: // this.array = arr;
052: // this.offset = offset;
053: // this.size = size;
054: // }
055:
056: Int16Pointer(VoidPointer p) {
057: super (p);
058: }
059:
060: /**
061: * returns the number of elements in array referenced by this object.
062: * If size is unknown returns -1.
063: */
064: @Override
065: public int size() {
066: return byteBase.size() / INT16_SIZE_FACTOR;
067: }
068:
069: /** returns the element at the specified position. */
070: public short get(int index) {
071: return (byteBase == null) ? (short) array[offset + index]
072: : byteBase.getInt16(index * INT16_SIZE_FACTOR);
073: }
074:
075: /** sets the element at the specified position. */
076: public void set(int index, short value) {
077: if (byteBase == null) {
078: array[offset + index] = (char) value;
079: } else {
080: byteBase.setInt16(index * INT16_SIZE_FACTOR, value);
081: }
082: }
083:
084: /** returns the element at the specified position. */
085: public char getChar(int index) {
086: return (byteBase == null) ? array[offset + index] : byteBase
087: .getChar(index * INT16_SIZE_FACTOR);
088: }
089:
090: /** sets the element at the specified position. */
091: public void setChar(int index, char value) {
092: if (byteBase == null) {
093: array[offset + index] = value;
094: } else {
095: byteBase.setChar(index * INT16_SIZE_FACTOR, value);
096: }
097: }
098:
099: /**
100: * This method transfers chars into the given destination array.
101: *
102: * @param dst - The array into which chars are to be written
103: * @param offset - The offset within the array of the first element to be written;
104: * must be non-negative and no larger than dst.length
105: * @param length - The maximum number of elements to be written to the given array;
106: * must be non-negative and no larger than dst.length - offset
107: */
108: public void getChar(char[] dst, int offset, int length) {
109: if (byteBase != null) {
110: byteBase.getChar(dst, offset, length);
111: } else {
112: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
113: }
114: }
115:
116: /**
117: * This method transfers chars from the given destination array.
118: *
119: * @param src - The array from which chars are to be read
120: * @param offset - The offset within the array of the first element to be read;
121: * must be non-negative and no larger than dst.length
122: * @param length - The maximum number of elements to be read from the given array;
123: * must be non-negative and no larger than dst.length - offset
124: */
125: public void setChar(char[] src, int offset, int length) {
126: if (byteBase != null) {
127: byteBase.setChar(src, offset, length);
128: } else {
129: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
130: }
131: }
132:
133: /**
134: * This method transfers short values into the given destination array.
135: *
136: * @param dst - The array into which values are to be written
137: * @param offset - The offset within the array of the first element to be written;
138: * must be non-negative and no larger than dst.length
139: * @param length - The maximum number of elements to be written to the given array;
140: * must be non-negative and no larger than dst.length - offset
141: */
142: public void get(short[] dst, int offset, int length) {
143: if (byteBase != null) {
144: byteBase.getInt16(dst, offset, length);
145: } else {
146: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
147: }
148: }
149:
150: /**
151: * This method transfers short values from the given destination array.
152: *
153: * @param src - The array from which values are to be read
154: * @param offset - The offset within the array of the first element to be read;
155: * must be non-negative and no larger than dst.length
156: * @param length - The maximum number of elements to be read from the given array;
157: * must be non-negative and no larger than dst.length - offset
158: */
159: public void set(short[] src, int offset, int length) {
160: if (byteBase != null) {
161: byteBase.setInt16(src, offset, length);
162: } else {
163: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
164: }
165: }
166:
167: /**
168: * returns class that represents the pointer to specified index.
169: */
170: public Int16Pointer getElementPointer(int index) {
171: if (byteBase != null) {
172: return new Int16Pointer(byteBase
173: .getBytesBaseElementPointer(index
174: * INT16_SIZE_FACTOR, INT16_SIZE_FACTOR));
175: }
176: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
177: }
178:
179: /**
180: * @see VoidPointer#isDirect()
181: */
182: @Override
183: public boolean isDirect() {
184: return byteBase != null ? byteBase.isDirect() : false;
185: }
186:
187: /** convert UTF16 bytes to String */
188: public String getString() {
189: if (byteBase != null) {
190: return byteBase.getString();
191: }
192: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
193: }
194:
195: /** convert UTF16 bytes to String */
196: public String getString(long strlen) {
197: if (byteBase != null) {
198: return byteBase.getString(strlen);
199: }
200: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
201: }
202:
203: /**
204: * Convert String to 0 terminated UTF16 (Unicode) string.
205: * And set it to buffer
206: */
207: public void setString(String str) {
208: if (byteBase != null) {
209: byteBase.setString(str);
210: } else {
211: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
212: }
213: }
214:
215: public void fill(short value, int size) {
216: if (byteBase != null) {
217: int s = size();
218: for (int i = 0; i < size && i < s; i++) {
219: byteBase.setInt16(i * INT16_SIZE_FACTOR, value);
220: }
221: } else {
222: throw new UnsupportedOperationException("not implemented"); //$NON-NLS-1$
223: }
224: }
225: }
|