| Frames | No Frames |
1: /* Copyright (C) 2000, 2002, 2005 Free Software Foundation 2: 3: This file is part of GNU Classpath. 4: 5: GNU Classpath is free software; you can redistribute it and/or modify 6: it under the terms of the GNU General Public License as published by 7: the Free Software Foundation; either version 2, or (at your option) 8: any later version. 9: 10: GNU Classpath is distributed in the hope that it will be useful, but 11: WITHOUT ANY WARRANTY; without even the implied warranty of 12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13: General Public License for more details. 14: 15: You should have received a copy of the GNU General Public License 16: along with GNU Classpath; see the file COPYING. If not, write to the 17: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18: 02110-1301 USA. 19: 20: Linking this library statically or dynamically with other modules is 21: making a combined work based on this library. Thus, the terms and 22: conditions of the GNU General Public License cover the whole 23: combination. 24: 25: As a special exception, the copyright holders of this library give you 26: permission to link this library with independent modules to produce an 27: executable, regardless of the license terms of these independent 28: modules, and to copy and distribute the resulting executable under 29: terms of your choice, provided that you also meet, for each linked 30: independent module, the terms and conditions of the license of that 31: module. An independent module is a module which is not derived from 32: or based on this library. If you modify this library, you may extend 33: this exception to your version of the library, but you are not 34: obligated to do so. If you do not wish to do so, delete this 35: exception statement from your version. */ 36: 37: package java.awt.image; 38: 39: /* This is one of several classes that are nearly identical. Maybe we 40: should have a central template and generate all these files. This 41: is one of the cases where templates or macros would have been 42: useful to have in Java. 43: 44: This file has been created using search-replace. My only fear is 45: that these classes will grow out-of-sync as of a result of changes 46: that are not propagated to the other files. As always, mirroring 47: code is a maintenance nightmare. */ 48: 49: /** 50: * A {@link DataBuffer} that uses an array of <code>int</code> primitives 51: * to represent each of its banks. 52: * 53: * @author Rolf W. Rasmussen (rolfwr@ii.uib.no) 54: */ 55: public final class DataBufferInt extends DataBuffer 56: { 57: private int[] data; 58: private int[][] bankData; 59: 60: /** 61: * Creates a new data buffer with a single data bank containing the 62: * specified number of <code>int</code> elements. 63: * 64: * @param size the number of elements in the data bank. 65: */ 66: public DataBufferInt(int size) 67: { 68: super(TYPE_INT, size, 1, 0); 69: bankData = new int[1][]; 70: data = new int[size]; 71: bankData[0] = data; 72: } 73: 74: /** 75: * Creates a new data buffer with the specified number of data banks, 76: * each containing the specified number of <code>int</code> elements. 77: * 78: * @param size the number of elements in the data bank. 79: * @param numBanks the number of data banks. 80: */ 81: public DataBufferInt(int size, int numBanks) 82: { 83: super(TYPE_INT, size, numBanks); 84: bankData = new int[numBanks][size]; 85: data = bankData[0]; 86: } 87: 88: /** 89: * Creates a new data buffer backed by the specified data bank. 90: * <p> 91: * Note: there is no exception when <code>dataArray</code> is 92: * <code>null</code>, but in that case an exception will be thrown 93: * later if you attempt to access the data buffer. 94: * 95: * @param dataArray the data bank. 96: * @param size the number of elements in the data bank. 97: */ 98: public DataBufferInt(int[] dataArray, int size) 99: { 100: super(TYPE_INT, size, 1, 0); 101: bankData = new int[1][]; 102: data = dataArray; 103: bankData[0] = data; 104: } 105: 106: /** 107: * Creates a new data buffer backed by the specified data bank, with 108: * the specified offset to the first element. 109: * <p> 110: * Note: there is no exception when <code>dataArray</code> is 111: * <code>null</code>, but in that case an exception will be thrown 112: * later if you attempt to access the data buffer. 113: * 114: * @param dataArray the data bank. 115: * @param size the number of elements in the data bank. 116: * @param offset the offset to the first element in the array. 117: */ 118: public DataBufferInt(int[] dataArray, int size, int offset) 119: { 120: super(TYPE_INT, size, 1, offset); 121: bankData = new int[1][]; 122: data = dataArray; 123: bankData[0] = data; 124: } 125: 126: /** 127: * Creates a new data buffer backed by the specified data banks. 128: * 129: * @param dataArray the data banks. 130: * @param size the number of elements in the data bank. 131: * 132: * @throws NullPointerException if <code>dataArray</code> is 133: * <code>null</code>. 134: */ 135: public DataBufferInt(int[][] dataArray, int size) 136: { 137: super(TYPE_INT, size, dataArray.length); 138: bankData = dataArray; 139: data = bankData[0]; 140: } 141: 142: /** 143: * Creates a new data buffer backed by the specified data banks, with 144: * the specified offsets to the first element in each bank. 145: * 146: * @param dataArray the data banks. 147: * @param size the number of elements in the data bank. 148: * @param offsets the offsets to the first element in each data bank. 149: * 150: * @throws NullPointerException if <code>dataArray</code> is 151: * <code>null</code>. 152: */ 153: public DataBufferInt(int[][] dataArray, int size, int[] offsets) 154: { 155: super(TYPE_INT, size, dataArray.length, offsets); 156: bankData = dataArray; 157: data = bankData[0]; 158: } 159: 160: /** 161: * Returns the first data bank. 162: * 163: * @return The first data bank. 164: */ 165: public int[] getData() 166: { 167: return data; 168: } 169: 170: /** 171: * Returns a data bank. 172: * 173: * @param bank the bank index. 174: * @return A data bank. 175: */ 176: public int[] getData(int bank) 177: { 178: return bankData[bank]; 179: } 180: 181: /** 182: * Returns the array underlying this <code>DataBuffer</code>. 183: * 184: * @return The data banks. 185: */ 186: public int[][] getBankData() 187: { 188: return bankData; 189: } 190: 191: /** 192: * Returns an element from the first data bank. The <code>offset</code> is 193: * added to the specified index before accessing the underlying data array. 194: * 195: * @param i the element index. 196: * @return The element. 197: */ 198: public int getElem(int i) 199: { 200: return data[i+offset]; 201: } 202: 203: /** 204: * Returns an element from a particular data bank. The <code>offset</code> 205: * is added to the specified index before accessing the underlying data 206: * array. 207: * 208: * @param bank the bank index. 209: * @param i the element index. 210: * @return The element. 211: */ 212: public int getElem(int bank, int i) 213: { 214: // get unsigned int as int 215: return bankData[bank][i+offsets[bank]]; 216: } 217: 218: /** 219: * Sets an element in the first data bank. The offset (specified in the 220: * constructor) is added to <code>i</code> before updating the underlying 221: * data array. 222: * 223: * @param i the element index. 224: * @param val the new element value. 225: */ 226: public void setElem(int i, int val) 227: { 228: data[i+offset] = val; 229: } 230: 231: /** 232: * Sets an element in a particular data bank. The offset (specified in the 233: * constructor) is added to <code>i</code> before updating the underlying 234: * data array. 235: * 236: * @param bank the data bank index. 237: * @param i the element index. 238: * @param val the new element value. 239: */ 240: public void setElem(int bank, int i, int val) 241: { 242: bankData[bank][i+offsets[bank]] = val; 243: } 244: }