michael/lwjgl
michael
/
lwjgl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/LWJGL/lwjgl.git

This commit is contained in:
computer 2013-11-03 00:18:36 +00:00
parent e90e5dc172 f97ac09641
commit ec9b14090b
7 changed files with 113 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
src/java/org/lwjgl/NondirectBufferWrapper.java
View File

@ -1,409 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl;
import java.nio.ByteBuffer;
import java.nio.ShortBuffer;
import java.nio.IntBuffer;
import java.nio.FloatBuffer;
import java.nio.LongBuffer;
import java.nio.DoubleBuffer;
import java.nio.ByteOrder;
/**
* Utility class to cache thread local direct buffers so when we are passed a non-direct buffer,
* we can put its contents into a cached direct buffer and use that at the native side instead.
*
* Internal class, don't use.
* @author elias_naur <elias_naur@users.sourceforge.net>
* @version $Revision: 2762 $
* $Id: BufferChecks.java 2762 2007-04-11 16:13:05Z elias_naur $
*/
public final class NondirectBufferWrapper {
private static final int INITIAL_BUFFER_SIZE = 1;
private static final ThreadLocal<CachedBuffers> thread_buffer = new ThreadLocal<CachedBuffers>() {
protected CachedBuffers initialValue() {
return new CachedBuffers(INITIAL_BUFFER_SIZE);
}
};
private static CachedBuffers getCachedBuffers(int minimum_byte_size) {
CachedBuffers buffers = thread_buffer.get();
int current_byte_size = buffers.byte_buffer.capacity();
if (minimum_byte_size > current_byte_size) {
buffers = new CachedBuffers(minimum_byte_size);
thread_buffer.set(buffers);
}
return buffers;
}
public static ByteBuffer wrapNoCopyBuffer(ByteBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static ShortBuffer wrapNoCopyBuffer(ShortBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static IntBuffer wrapNoCopyBuffer(IntBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static LongBuffer wrapNoCopyBuffer(LongBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static FloatBuffer wrapNoCopyBuffer(FloatBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static DoubleBuffer wrapNoCopyBuffer(DoubleBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapNoCopyDirect(buf);
}
public static ByteBuffer wrapBuffer(ByteBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static ShortBuffer wrapBuffer(ShortBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static IntBuffer wrapBuffer(IntBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static LongBuffer wrapBuffer(LongBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static FloatBuffer wrapBuffer(FloatBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static DoubleBuffer wrapBuffer(DoubleBuffer buf, int size) {
BufferChecks.checkBufferSize(buf, size);
return wrapDirect(buf);
}
public static ByteBuffer wrapDirect(ByteBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static ShortBuffer wrapDirect(ShortBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static FloatBuffer wrapDirect(FloatBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static IntBuffer wrapDirect(IntBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static LongBuffer wrapDirect(LongBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static DoubleBuffer wrapDirect(DoubleBuffer buffer) {
if (!buffer.isDirect())
return doWrap(buffer);
return buffer;
}
public static ByteBuffer wrapNoCopyDirect(ByteBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static ShortBuffer wrapNoCopyDirect(ShortBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static FloatBuffer wrapNoCopyDirect(FloatBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static IntBuffer wrapNoCopyDirect(IntBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static LongBuffer wrapNoCopyDirect(LongBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static DoubleBuffer wrapNoCopyDirect(DoubleBuffer buffer) {
if (!buffer.isDirect())
return doNoCopyWrap(buffer);
return buffer;
}
public static void copy(ByteBuffer src, ByteBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
public static void copy(ShortBuffer src, ShortBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
public static void copy(IntBuffer src, IntBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
public static void copy(FloatBuffer src, FloatBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
public static void copy(LongBuffer src, LongBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
public static void copy(DoubleBuffer src, DoubleBuffer dst) {
if (dst != null && !dst.isDirect()) {
int saved_position = dst.position();
dst.put(src);
dst.position(saved_position);
}
}
private static ByteBuffer doNoCopyWrap(ByteBuffer buffer) {
ByteBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static ShortBuffer doNoCopyWrap(ShortBuffer buffer) {
ShortBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static IntBuffer doNoCopyWrap(IntBuffer buffer) {
IntBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static FloatBuffer doNoCopyWrap(FloatBuffer buffer) {
FloatBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static LongBuffer doNoCopyWrap(LongBuffer buffer) {
LongBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static DoubleBuffer doNoCopyWrap(DoubleBuffer buffer) {
DoubleBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.limit(buffer.limit());
direct_buffer.position(buffer.position());
return direct_buffer;
}
private static ByteBuffer lookupBuffer(ByteBuffer buffer) {
return getCachedBuffers(buffer.remaining()).byte_buffer;
}
private static ByteBuffer doWrap(ByteBuffer buffer) {
ByteBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static ShortBuffer lookupBuffer(ShortBuffer buffer) {
CachedBuffers buffers = getCachedBuffers(buffer.remaining()*2);
return buffer.order() == ByteOrder.LITTLE_ENDIAN ? buffers.short_buffer_little : buffers.short_buffer_big;
}
private static ShortBuffer doWrap(ShortBuffer buffer) {
ShortBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static FloatBuffer lookupBuffer(FloatBuffer buffer) {
CachedBuffers buffers = getCachedBuffers(buffer.remaining()*4);
return buffer.order() == ByteOrder.LITTLE_ENDIAN ? buffers.float_buffer_little : buffers.float_buffer_big;
}
private static FloatBuffer doWrap(FloatBuffer buffer) {
FloatBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static IntBuffer lookupBuffer(IntBuffer buffer) {
CachedBuffers buffers = getCachedBuffers(buffer.remaining()*4);
return buffer.order() == ByteOrder.LITTLE_ENDIAN ? buffers.int_buffer_little : buffers.int_buffer_big;
}
private static IntBuffer doWrap(IntBuffer buffer) {
IntBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static LongBuffer lookupBuffer(LongBuffer buffer) {
CachedBuffers buffers = getCachedBuffers(buffer.remaining()*8);
return buffer.order() == ByteOrder.LITTLE_ENDIAN ? buffers.long_buffer_little : buffers.long_buffer_big;
}
private static LongBuffer doWrap(LongBuffer buffer) {
LongBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static DoubleBuffer lookupBuffer(DoubleBuffer buffer) {
CachedBuffers buffers = getCachedBuffers(buffer.remaining()*8);
return buffer.order() == ByteOrder.LITTLE_ENDIAN ? buffers.double_buffer_little : buffers.double_buffer_big;
}
private static DoubleBuffer doWrap(DoubleBuffer buffer) {
DoubleBuffer direct_buffer = lookupBuffer(buffer);
direct_buffer.clear();
int saved_position = buffer.position();
direct_buffer.put(buffer);
buffer.position(saved_position);
direct_buffer.flip();
return direct_buffer;
}
private static final class CachedBuffers {
private final ByteBuffer byte_buffer;
private final ShortBuffer short_buffer_big;
private final IntBuffer int_buffer_big;
private final FloatBuffer float_buffer_big;
private final LongBuffer long_buffer_big;
private final DoubleBuffer double_buffer_big;
private final ShortBuffer short_buffer_little;
private final IntBuffer int_buffer_little;
private final FloatBuffer float_buffer_little;
private final LongBuffer long_buffer_little;
private final DoubleBuffer double_buffer_little;
private CachedBuffers(int size) {
this.byte_buffer = ByteBuffer.allocateDirect(size);
this.short_buffer_big = byte_buffer.asShortBuffer();
this.int_buffer_big = byte_buffer.asIntBuffer();
this.float_buffer_big = byte_buffer.asFloatBuffer();
this.long_buffer_big = byte_buffer.asLongBuffer();
this.double_buffer_big = byte_buffer.asDoubleBuffer();
this.byte_buffer.order(ByteOrder.LITTLE_ENDIAN);
this.short_buffer_little = byte_buffer.asShortBuffer();
this.int_buffer_little = byte_buffer.asIntBuffer();
this.float_buffer_little = byte_buffer.asFloatBuffer();
this.long_buffer_little = byte_buffer.asLongBuffer();
this.double_buffer_little = byte_buffer.asDoubleBuffer();
}
}
}

53
src/java/org/lwjgl/input/ControllerEvent.java
View File

@ -52,12 +52,18 @@ class ControllerEvent {
private int index;
/** Type of control that generated the event */
private int type;
/** True when a button is pressed, if this event was caused by the button */
private boolean buttonState;
/** True if this event was caused by the x axis */
private boolean xaxis;
/** True if this event was caused by the y axis */
private boolean yaxis;
/** The time stamp of this event */
private long timeStamp;
/** The value on a specified axis, if this event was caused by the x-axis */
private float xaxisValue;
/** The value on a specified axis, if this event was caused by the y-axis */
private float yaxisValue;
/**
* Create a new event
@ -70,12 +76,32 @@ class ControllerEvent {
* @param yaxis True if this event was caused by the y-axis
*/
ControllerEvent(Controller source,long timeStamp, int type,int index,boolean xaxis,boolean yaxis) {
this(source, timeStamp, type, index, false, xaxis, yaxis, 0, 0);
}
/**
* Create a new event
*
* @param source The source of the event
* @param timeStamp The time stamp given for this event
* @param type The type of control generating this event
* @param index The index of the input that generated the event
* @param buttonState True when a button is pressed, if this event was caused by the button
* @param xaxis True if this event was caused by the x-axis
* @param yaxis True if this event was caused by the y-axis
* @param xaxisValue The value on a specified axis, if this event was caused by the x-axis
* @param yaxisValue The value on a specified axis, if this event was caused by the y-axis
*/
ControllerEvent(Controller source,long timeStamp, int type,int index,boolean buttonState,boolean xaxis,boolean yaxis,float xaxisValue,float yaxisValue) {
this.source = source;
this.timeStamp = timeStamp;
this.type = type;
this.index = index;
this.buttonState = buttonState;
this.xaxis = xaxis;
this.yaxis = yaxis;
this.xaxisValue = xaxisValue;
this.yaxisValue = yaxisValue;
}
/**
@ -115,6 +141,15 @@ class ControllerEvent {
return type == BUTTON;
}
/**
* Check the button is pressed or not, when this event was caused
*
* @return True when a button is pressed, if this event was caused by the button
*/
public boolean getButtonState() {
return buttonState;
}
/**
* Check if this event was generated by a axis
*
@ -159,6 +194,24 @@ class ControllerEvent {
public boolean isYAxis() {
return yaxis;
}
/**
* Get the value on an X axis when this event was caused
*
* @return The value on a specified axis, if this event was caused by the x-axis
*/
public float getXAxisValue() {
return xaxisValue;
}
/**
* Get the value on an Y axis when this event was caused
*
* @return The value on a specified axis, if this event was caused by the y-axis
*/
public float getYAxisValue() {
return yaxisValue;
}
/*
* @see java.lang.Object#toString()

29
src/java/org/lwjgl/input/Controllers.java
View File

@ -262,12 +262,39 @@ public class Controllers {
/**
* Get the timestamp assigned to the current event
*
* @return The timestamp assigned ot the current event
* @return The timestamp assigned to the current event
*/
public static long getEventNanoseconds() {
return event.getTimeStamp();
}
/**
* Gets the state of the button that generated the current event
*
* @return True if button was down, or false if released
*/
public static boolean getEventButtonState() {
return event.getButtonState();
}
/**
* Get the value on an X axis of the current event
*
* @return The value on a x axis of the current event
*/
public static float getEventXAxisValue() {
return event.getXAxisValue();
}
/**
* Get the value on an Y axis of the current event
*
* @return The value on a y axis of the current event
*/
public static float getEventYAxisValue() {
return event.getYAxisValue();
}
/**
* Add an event to the stack of events that have been caused
*

6
src/java/org/lwjgl/input/Cursor.java
View File

@ -33,10 +33,10 @@ package org.lwjgl.input;
import java.nio.IntBuffer;
import org.lwjgl.BufferChecks;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.NondirectBufferWrapper;
import org.lwjgl.Sys;
/**
@ -86,9 +86,9 @@ public class Cursor {
synchronized (OpenGLPackageAccess.global_lock) {
if ((getCapabilities() & CURSOR_ONE_BIT_TRANSPARENCY) == 0)
throw new LWJGLException("Native cursors not supported");
images = NondirectBufferWrapper.wrapBuffer(images, width*height*numImages);
BufferChecks.checkBufferSize(images, width*height*numImages);
if (delays != null)
delays = NondirectBufferWrapper.wrapBuffer(delays, numImages);
BufferChecks.checkBufferSize(delays, numImages);
if (!Mouse.isCreated())
throw new IllegalStateException("Mouse must be created before creating cursor objects");
if (width*height*numImages > images.remaining())

17
src/java/org/lwjgl/input/JInputController.java
View File

@ -208,7 +208,8 @@ class JInputController implements Controller {
buttonState[buttonIndex] = event.getValue() != 0;
// fire button pressed event
Controllers.addEvent(new ControllerEvent(this,event.getNanos(),ControllerEvent.BUTTON,buttonIndex,false,false));
Controllers.addEvent(new ControllerEvent(this,event.getNanos(),ControllerEvent.BUTTON,buttonIndex,
buttonState[buttonIndex],false,false,0,0));
}
// handle pov events
@ -232,6 +233,8 @@ class JInputController implements Controller {
Component axis = event.getComponent();
int axisIndex = axes.indexOf(axis);
float value = axis.getPollData();
float xaxisValue = 0;
float yaxisValue = 0;
// fixed dead zone since most axis don't report it :(
if (Math.abs(value) < deadZones[axisIndex]) {
@ -246,9 +249,17 @@ class JInputController implements Controller {
// normalize the value based on maximum value read in the past
value /= axesMax[axisIndex];
if (axisIndex == xaxis) {
xaxisValue = value;
}
if (axisIndex == yaxis) {
yaxisValue = value;
}
// fire event
Controllers.addEvent(new ControllerEvent(this,event.getNanos(),ControllerEvent.AXIS,axisIndex,
axisIndex == xaxis,axisIndex == yaxis));
Controllers.addEvent(new ControllerEvent(this,event.getNanos(),ControllerEvent.AXIS,axisIndex,false,
axisIndex == xaxis,axisIndex == yaxis,xaxisValue,yaxisValue));
axesValue[axisIndex] = value;
}
}

23
src/java/org/lwjgl/opengl/WindowsDisplay.java
View File

@ -270,15 +270,10 @@ final class WindowsDisplay implements DisplayImplementation {
parent.addFocusListener(parent_focus_tracker = new FocusAdapter() {
public void focusGained(FocusEvent e) {
parent_focused.set(true);
// This is needed so that the last focused component AWT remembers is NOT our Canvas
WindowsDisplay.this.parent.setFocusable(false);
WindowsDisplay.this.parent.setFocusable(true);
// Clear AWT focus owner
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
clearAWTFocus();
}
});
clearAWTFocus();
}
grabFocus();
} catch (LWJGLException e) {
@ -376,11 +371,6 @@ final class WindowsDisplay implements DisplayImplementation {
restoreDisplayMode();
}
if (parent == null) {
if(maximized) {
showWindow(getHwnd(), SW_MAXIMIZE);
} else {
showWindow(getHwnd(), SW_RESTORE);
}
setForegroundWindow(getHwnd());
}
setFocus(getHwnd());
@ -402,6 +392,15 @@ final class WindowsDisplay implements DisplayImplementation {
private static native void setForegroundWindow(long hwnd);
private static native void setFocus(long hwnd);
private void clearAWTFocus() {
// This is needed so that the last focused component AWT remembers is NOT our Canvas
WindowsDisplay.this.parent.setFocusable(false);
WindowsDisplay.this.parent.setFocusable(true);
// Clear AWT focus owner
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
}
private void grabFocus() {
if ( parent == null )
setFocus(getHwnd());

33
src/java/org/lwjgl/util/generator/JavaMethodsGenerator.java
View File

@ -599,22 +599,6 @@ public class JavaMethodsGenerator {
}
}
private static void printNondirectParameterCopies(PrintWriter writer, MethodDeclaration method, Mode mode) {
for (ParameterDeclaration param : method.getParameters()) {
Class java_type = Utils.getJavaType(param.getType());
if (Utils.isAddressableType(java_type) &&
(mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null) &&
(mode != Mode.AUTOS || getAutoTypeParameter(method, param) == null) &&
param.getAnnotation(Result.class) == null) {
if (Buffer.class.isAssignableFrom(java_type)) {
boolean out_parameter = param.getAnnotation(OutParameter.class) != null;
if (out_parameter)
writer.println("\t\tNondirectBufferWrapper.copy(" + param.getSimpleName() + ", " + param.getSimpleName() + SAVED_PARAMETER_POSTFIX + ");");
}
}
}
}
private static void printParameterChecks(PrintWriter writer, MethodDeclaration method, Map<ParameterDeclaration, TypeInfo> typeinfos, Mode mode, final boolean generate_error_checks) {
if ( mode == Mode.NORMAL ) {
final GenerateAutos gen_autos_annotation = method.getAnnotation(GenerateAutos.class);
@ -650,10 +634,9 @@ public class JavaMethodsGenerator {
can_be_null = check_annotation.canBeNull();
}
if ((Buffer.class.isAssignableFrom(java_type) || PointerBuffer.class.isAssignableFrom(java_type)) && param.getAnnotation(Constant.class) == null) {
boolean indirect_buffer_allowed = false && param.getAnnotation(CachedReference.class) == null; // DISABLED: indirect buffer support
boolean out_parameter = param.getAnnotation(OutParameter.class) != null;
TypeInfo typeinfo = typeinfos.get(param);
printParameterCheck(writer, method, param.getSimpleName(), typeinfo.getType().getSimpleName(), check_value, can_be_null, param.getAnnotation(NullTerminated.class), indirect_buffer_allowed, out_parameter, generate_error_checks);
printParameterCheck(writer, method, param.getSimpleName(), typeinfo.getType().getSimpleName(), check_value, can_be_null, param.getAnnotation(NullTerminated.class), out_parameter, generate_error_checks);
} else if ( String.class.equals(java_type)) {
if (!can_be_null)
writer.println("\t\tBufferChecks.checkNotNull(" + param.getSimpleName() + ");");
@ -664,13 +647,10 @@ public class JavaMethodsGenerator {
}
}
if (method.getAnnotation(CachedResult.class) != null)
printParameterCheck(writer, method, Utils.CACHED_BUFFER_NAME, null, null, true, null, false, false, generate_error_checks);
printParameterCheck(writer, method, Utils.CACHED_BUFFER_NAME, null, null, true, null, false, generate_error_checks);
}
private static void printParameterCheck(PrintWriter writer, MethodDeclaration method, String name, String type, String check_value, boolean can_be_null, NullTerminated null_terminated, boolean indirect_buffer_allowed, boolean out_parameter, final boolean generate_error_checks) {
if (indirect_buffer_allowed && out_parameter) {
writer.println("\t\t" + type + " " + name + SAVED_PARAMETER_POSTFIX + " = " + name + ";");
}
private static void printParameterCheck(PrintWriter writer, MethodDeclaration method, String name, String type, String check_value, boolean can_be_null, NullTerminated null_terminated, boolean out_parameter, boolean generate_error_checks) {
String tabs;
if (can_be_null) {
writer.print("\t\tif (" + name + " != null)");
@ -681,12 +661,7 @@ public class JavaMethodsGenerator {
tabs = "\t\t\t";
} else
tabs = "\t\t";
if (indirect_buffer_allowed) {
writer.print(tabs + name + " = NondirectBufferWrapper.wrap");
if (out_parameter)
writer.print("NoCopy");
} else
writer.print(tabs + "BufferChecks.check");
writer.print(tabs + "BufferChecks.check");
if (check_value != null && check_value.length() > 0) {
writer.print("Buffer");
if ( "Buffer".equals(type) )