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: package org.apache.harmony.awt.nativebridge;
018:
019: public class PointerPointer extends VoidPointer {
020:
021: private static final int PP_SIZE_FACTOR = ByteBase.POINTER_SIZE;
022:
023: PointerPointer(int size, boolean direct) {
024: super (size * PP_SIZE_FACTOR, direct);
025: }
026:
027: PointerPointer(ByteBase base) {
028: super (base);
029: }
030:
031: /**
032: * Creates Pointer based on native pointer to pointer
033: */
034: PointerPointer(long ptrPtr) {
035: super (ptrPtr);
036: }
037:
038: /**
039: * Creates Pointer to the given pointer.
040: * Pointer should be unlocked after usage of the created PointerPointer
041: * @param pointer
042: * @param direct
043: */
044: PointerPointer(VoidPointer pointer, boolean direct) {
045: super (PP_SIZE_FACTOR, direct);
046: long addr = (pointer != null) ? pointer.longLockPointer() : 0;
047: setAddress(0, addr);
048: }
049:
050: /** returns the number of elements in array referenced by this object. If size is unknown returns -1. */
051: @Override
052: public int size() {
053: int tmp = byteBase.size();
054: return tmp == -1 ? -1 : tmp / PP_SIZE_FACTOR;
055: }
056:
057: /** returns the element at the specified position. */
058: public VoidPointer get(int index) {
059: long addr = byteBase.getAddress(index * PP_SIZE_FACTOR);
060: return (addr != 0) ? new Int8Pointer(addr) : null;
061: }
062:
063: /** returns the element at the specified position. */
064: public long getAddress(int index) {
065: return byteBase.getAddress(index * PP_SIZE_FACTOR);
066: }
067:
068: /** sets the element at the specified position. */
069: public void set(int index, VoidPointer value) {
070: byteBase.setAddress(index * PP_SIZE_FACTOR, value.lock());
071: value.release();
072: }
073:
074: /** sets the element at the specified position. */
075: public void setAddress(int index, long value) {
076: byteBase.setAddress(index * PP_SIZE_FACTOR, value);
077: }
078:
079: /**
080: * This method transfers int values into the given destination array.
081: *
082: * @param dst - The array into which values are to be written
083: * @param offset - The offset within the array of the first element to be written;
084: * must be non-negative and no larger than dst.length
085: * @param length - The maximum number of elements to be written to the given array;
086: * must be non-negative and no larger than dst.length - offset
087: */
088: public void get(VoidPointer[] dst, int offset, int length) {
089: // TODO Implement
090: throw new UnsupportedOperationException("Not implemented"); //$NON-NLS-1$
091: }
092:
093: public void getAddress(long[] dst, int offset, int length) {
094: // TODO Implement
095: throw new UnsupportedOperationException("Not implemented"); //$NON-NLS-1$
096: }
097:
098: /**
099: * This method transfers short values from the given destination array.
100: *
101: * @param src - The array from which values are to be read
102: * @param offset - The offset within the array of the first element to be read;
103: * must be non-negative and no larger than dst.length
104: * @param length - The maximum number of elements to be read from the given array;
105: * must be non-negative and no larger than dst.length - offset
106: */
107: public void set(VoidPointer[] src, int offset, int length) {
108: // TODO Implement
109: throw new UnsupportedOperationException("Not implemented"); //$NON-NLS-1$
110: }
111:
112: public void setAddress(long[] src, int offset, int length) {
113: // TODO Implement
114: throw new UnsupportedOperationException("Not implemented"); //$NON-NLS-1$
115: }
116:
117: /**
118: * returns class that represents the pointer to specified index.
119: */
120: public PointerPointer getElementPointer(int index) {
121: return new PointerPointer(byteBase.getBytesBaseElementPointer(
122: index * PP_SIZE_FACTOR, PP_SIZE_FACTOR));
123: }
124:
125: public void fill(long value, int size) {
126: int this Size = size();
127: for (int i = 0; i < size && i < thisSize; i++) {
128: byteBase.setAddress(i * PP_SIZE_FACTOR, value);
129: }
130: }
131: }
|