Source Code Cross Referenced for Int16Pointer.java in  » Apache-Harmony-Java-SE » org-package » org » apache » harmony » awt » nativebridge » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Apache Harmony Java SE » org package » org.apache.harmony.awt.nativebridge 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.