From 0ea6688e41c31b0e2c8dba73582c935562885b44 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Mon, 10 Jul 2023 16:39:36 +0200 Subject: GlueGen JavaCallback: Add optional custom 'Callback-UserParamClass` for non-compound `UserParam` types to have more clarity in resulting API --- .../com/jogamp/gluegen/JavaCallbackEmitter.java | 25 +- src/java/com/jogamp/gluegen/JavaConfiguration.java | 48 +- src/java/com/jogamp/gluegen/JavaEmitter.java | 22 +- .../test/junit/generation/Test4JavaCallback.java | 586 ++++++++++----------- .../generation/test2-CustomJavaIfCode.java.stub | 4 +- .../generation/test2-CustomJavaImplCode.java.stub | 12 +- .../jogamp/gluegen/test/junit/generation/test2.cfg | 15 +- 7 files changed, 376 insertions(+), 336 deletions(-) (limited to 'src') diff --git a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java index 05192d3..dbd38aa 100644 --- a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java +++ b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java @@ -55,6 +55,7 @@ public final class JavaCallbackEmitter { final boolean userParamIsMappedToID; final String userParamIDMapInstanceName; + final String userParamClassName; final boolean customKeyClass; final String KeyClassName; final boolean useDataMap; @@ -98,9 +99,17 @@ public final class JavaCallbackEmitter { userParamIDMapInstanceName = null; } - if( null != javaCallback.setFuncKeyClassName ) { + if( userParamIsCompound ) { + userParamClassName = setFuncUserParamTypeName; + } else if( null != javaCallback.userParamClassName ) { + userParamClassName = javaCallback.userParamClassName; + } else { + userParamClassName = "Object"; + } + + if( null != javaCallback.customKeyClassName ) { customKeyClass = true;; - KeyClassName = javaCallback.setFuncKeyClassName; + KeyClassName = javaCallback.customKeyClassName; useDataMap = true; } else { customKeyClass = false; @@ -127,7 +136,7 @@ public final class JavaCallbackEmitter { unit.emitln(" public "+info.cbFuncTypeName+" get"+capIfaceName+"("+KeyClassName+" key);"); unit.emitln(); emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public Object get"+capIfaceName+"UserParam("+KeyClassName+" key);"); + unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key);"); unit.emitln(); emitJavaBriefAPIDoc(unit, "Releases all callback data ", "mapped via ", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public int releaseAll"+capIfaceName+"();"); @@ -143,7 +152,7 @@ public final class JavaCallbackEmitter { unit.emitln(" public "+info.cbFuncTypeName+" get"+capIfaceName+"();"); unit.emitln(); emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public Object get"+capIfaceName+"UserParam();"); + unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam();"); unit.emitln(); emitJavaBriefAPIDoc(unit, "Releases callback data ", "", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public void release"+capIfaceName+"();"); @@ -181,7 +190,7 @@ public final class JavaCallbackEmitter { unit.emitln(); emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public final Object get"+capIfaceName+"UserParam("+KeyClassName+" key) {"); + unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key) {"); unit.emitln(" synchronized( "+lockInstanceName+" ) {"); unit.emitln(" final "+DataClassName+" value = "+dataMapInstanceName+".get(key);"); unit.emitln(" return null != value ? value.param : null;"); @@ -234,7 +243,7 @@ public final class JavaCallbackEmitter { unit.emitln(); emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public final Object get"+capIfaceName+"UserParam() {"); + unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam() {"); unit.emitln(" synchronized( "+lockInstanceName+" ) {"); unit.emitln(" final "+DataClassName+" value = "+dataInstanceName+";"); unit.emitln(" return null != value ? value.param : null;"); @@ -524,12 +533,12 @@ public final class JavaCallbackEmitter { unit.emitln(" final "+origUserParamJType[0]+" "+info.cbFuncUserParamName+" = "+origUserParamJType[0]+".derefPointer(nativeUserParam);"); useParamLocal[0] = true; } else if( userParamIsMappedToID && userParamIsKey ) { - unit.emitln(" final Object "+info.cbFuncUserParamName+";"); + unit.emitln(" final "+userParamClassName+" "+info.cbFuncUserParamName+";"); } unit.emitln(" final "+DataClassName+" value;"); unit.emitln(" synchronized( "+lockInstanceName+" ) {"); if( userParamIsMappedToID && userParamIsKey && !mapNativePtrToCompound[0] ) { - unit.emitln(" "+info.cbFuncUserParamName+" = "+userParamIDMapInstanceName+".get(nativeUserParam);"); + unit.emitln(" "+info.cbFuncUserParamName+" = ("+userParamClassName+") "+userParamIDMapInstanceName+".get(nativeUserParam);"); useParamLocal[0] = true; } if( useDataMap ) { diff --git a/src/java/com/jogamp/gluegen/JavaConfiguration.java b/src/java/com/jogamp/gluegen/JavaConfiguration.java index e530e0c..f5242b8 100644 --- a/src/java/com/jogamp/gluegen/JavaConfiguration.java +++ b/src/java/com/jogamp/gluegen/JavaConfiguration.java @@ -192,19 +192,23 @@ public class JavaConfiguration { final String setFuncName; final int setFuncUserParamIdx; // optional final List cbFuncKeyIndices = new ArrayList(); - final String setFuncKeyClassName; // optional + final String userParamClassName; // optional + final String customKeyClassName; // optional final List setFuncKeyIndices = new ArrayList(); - JavaCallbackDef(final String cbFuncTypeName, final int cbFuncUserParamIdx, final String setFuncName, final int setFuncUserParamIdx, final String setFuncKeyClassName) { + JavaCallbackDef(final String cbFuncTypeName, final int cbFuncUserParamIdx, final String setFuncName, final int setFuncUserParamIdx, + final String userParamClassName, final String customKeyClassName) { this.cbFuncTypeName = cbFuncTypeName; this.cbFuncUserParamIdx = cbFuncUserParamIdx; this.setFuncName = setFuncName; this.setFuncUserParamIdx = setFuncUserParamIdx; - this.setFuncKeyClassName = setFuncKeyClassName; + this.userParamClassName = userParamClassName; + this.customKeyClassName = customKeyClassName; } @Override public String toString() { - return String.format("JavaCallbackDef[cbFunc[type %s, userParamIdx %d, keys %s], set[%s, keys %s, userParamIdx %d, KeyClass %s]]", - cbFuncTypeName, cbFuncUserParamIdx, cbFuncKeyIndices.toString(), setFuncName, setFuncKeyIndices.toString(), setFuncUserParamIdx, setFuncKeyClassName); + return String.format("JavaCallbackDef[cbFunc[type %s, userParamIdx %d, keys %s], set[%s, keys %s, userParamIdx %d], Class[UserParam %s, Key %s]]", + cbFuncTypeName, cbFuncUserParamIdx, cbFuncKeyIndices.toString(), setFuncName, setFuncKeyIndices.toString(), setFuncUserParamIdx, + userParamClassName, customKeyClassName); } } private final List javaCallbackList = new ArrayList(); @@ -1696,13 +1700,26 @@ public class JavaConfiguration { final int setFuncUserParamIdx = Integer.parseInt(tok.nextToken()); final String cbFuncTypeName = tok.nextToken(); final int cbFuncUserParamIdx = Integer.parseInt(tok.nextToken()); - final String cbFuncKeyClassName; + final String userParamClassName; + final String customKeyClassName; if( tok.hasMoreTokens() ) { - cbFuncKeyClassName = tok.nextToken(); + final String s = tok.nextToken(); + if( s.length() == 0 || s.equals("null") ) { + userParamClassName = null; + } else { + userParamClassName = s; + } + if( tok.hasMoreTokens() ) { + customKeyClassName = tok.nextToken(); + } else { + customKeyClassName = null; + } } else { - cbFuncKeyClassName = null; + userParamClassName = null; + customKeyClassName = null; } - final JavaCallbackDef jcd = new JavaCallbackDef(cbFuncTypeName, cbFuncUserParamIdx, setFuncName, setFuncUserParamIdx, cbFuncKeyClassName); + final JavaCallbackDef jcd = new JavaCallbackDef(cbFuncTypeName, cbFuncUserParamIdx, setFuncName, setFuncUserParamIdx, + userParamClassName, customKeyClassName); javaCallbackList.add(jcd); javaCallbackSetFuncToDef.put(setFuncName, jcd); } catch (final NoSuchElementException e) { @@ -2408,15 +2425,17 @@ public class JavaConfiguration { final String setFuncName; final List setFuncKeyIndices; - final String setFuncKeyClassName; final int setFuncUserParamIdx; + final String userParamClassName; // optional + final String customKeyClassName; // optional boolean setFuncProcessed; int setFuncCBParamIdx; boolean keyClassEmitted; public JavaCallbackInfo(final String cbFuncTypeName, final String cbSimpleClazzName, final String cbFQClazzName, final String staticCBMethodSignature, final FunctionType cbFuncType, final MethodBinding cbFuncBinding, final int cbFuncUserParamIdx, final List cbFuncKeyIndices, - final String setFuncName, final int setFuncUserParamIdx, final List setFuncKeyIndices, final String setFuncKeyClassName) { + final String setFuncName, final int setFuncUserParamIdx, final List setFuncKeyIndices, + final String userParamClassName, final String customKeyClassName) { this.cbFuncTypeName = cbFuncTypeName; this.cbSimpleClazzName = cbSimpleClazzName; this.cbFQClazzName = cbFQClazzName; @@ -2443,8 +2462,9 @@ public class JavaConfiguration { } this.setFuncName = setFuncName; this.setFuncKeyIndices = setFuncKeyIndices; - this.setFuncKeyClassName = setFuncKeyClassName; this.setFuncUserParamIdx = setFuncUserParamIdx; + this.userParamClassName = userParamClassName; + this.customKeyClassName = customKeyClassName; this.setFuncProcessed = false; this.setFuncCBParamIdx = -1; this.keyClassEmitted = false; @@ -2479,11 +2499,11 @@ public class JavaConfiguration { @Override public String toString() { - return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s, KeyClass '%s'], %s]", + return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s], Class[UserParam '%s', Key '%s'], %s]", cbFuncTypeName, staticCBMethodSignature, cbFuncUserParamIdx, cbFuncUserParamName, cbFuncUserParamType.getSignature(null).toString(), cbFuncKeyIndices.toString(), setFuncName, setFuncProcessed, setFuncCBParamIdx, setFuncUserParamIdx, - setFuncKeyIndices.toString(), setFuncKeyClassName, + setFuncKeyIndices.toString(), userParamClassName, customKeyClassName, cbFuncType.toString(cbFuncTypeName, false, true)); } } diff --git a/src/java/com/jogamp/gluegen/JavaEmitter.java b/src/java/com/jogamp/gluegen/JavaEmitter.java index 88cff27..576e9bc 100644 --- a/src/java/com/jogamp/gluegen/JavaEmitter.java +++ b/src/java/com/jogamp/gluegen/JavaEmitter.java @@ -1474,14 +1474,15 @@ public class JavaEmitter implements GlueEmitter { } final JavaCallbackInfo jcbi1 = new JavaCallbackInfo(jcbd.cbFuncTypeName, cbSimpleClazzName, cbFQClazzName, jcbi0.staticCBMethodSignature, funcType, jcbi0.cbFuncBinding, jcbi0.cbFuncUserParamIdx, jcbd.cbFuncKeyIndices, - jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, jcbd.setFuncKeyClassName); + jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, + jcbd.userParamClassName, jcbd.customKeyClassName); cfg.setFuncToJavaCallbackMap.put(jcbd.setFuncName, jcbi1); LOG.log(INFO, "JavaCallbackInfo: Reusing {0} -> {1}", jcbd.setFuncName, jcbi0); } else { final StringBuilder cbMethodSignature = new StringBuilder(); javaUnit.emitln(" /** JavaCallback interface: "+jcbd.cbFuncTypeName+" -> "+funcType.toString(jcbd.cbFuncTypeName, false, true)+" */"); javaUnit.emitln(" public static interface "+cbSimpleClazzName+" {"); - final List mbs = generateFunctionInterfaceCode(javaUnit, funcSym, jcbd.cbFuncUserParamIdx, cbMethodSignature); + final List mbs = generateFunctionInterfaceCode(javaUnit, funcSym, jcbd, cbMethodSignature); javaUnit.emitln(" }"); javaUnit.emitln(); if( 1 != mbs.size() ) { @@ -1494,7 +1495,8 @@ public class JavaEmitter implements GlueEmitter { } final JavaCallbackInfo jcbi1 = new JavaCallbackInfo(jcbd.cbFuncTypeName, cbSimpleClazzName, cbFQClazzName, cbMethodSignature.toString(), funcType, cbFuncBinding, jcbd.cbFuncUserParamIdx, jcbd.cbFuncKeyIndices, - jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, jcbd.setFuncKeyClassName); + jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, + jcbd.userParamClassName, jcbd.customKeyClassName); cfg.setFuncToJavaCallbackMap.put(jcbd.setFuncName, jcbi1); javaCallbackInterfaceMap.put(cbFQClazzName, jcbi1); LOG.log(INFO, "JavaCallbackInfo: Added {0} -> {1}", jcbd.setFuncName, jcbi1); @@ -1502,15 +1504,23 @@ public class JavaEmitter implements GlueEmitter { } private final Map javaCallbackInterfaceMap = new HashMap(); - private List generateFunctionInterfaceCode(final JavaCodeUnit javaUnit, final FunctionSymbol funcSym, final int userParamIdx, final StringBuilder methodSignature) { + private List generateFunctionInterfaceCode(final JavaCodeUnit javaUnit, final FunctionSymbol funcSym, final JavaCallbackDef jcbd, final StringBuilder methodSignature) { // Emit method call and associated native code MethodBinding mb = bindFunction(funcSym, true /* forInterface */, machDescJava, null, null); // Replace optional userParam argument 'void*' with Object + final int userParamIdx = jcbd.cbFuncUserParamIdx; if( 0 <= userParamIdx && userParamIdx < mb.getNumArguments() ) { final JavaType t = mb.getJavaArgumentType(userParamIdx); if ( t.isCVoidPointerType() ) { - mb = mb.replaceJavaArgumentType(userParamIdx, JavaType.forObjectClass()); + final JavaType mappedType; + if( null != jcbd.userParamClassName ) { + mappedType = JavaType.createForNamedClass( jcbd.userParamClassName ); + mb = mb.replaceJavaArgumentType(userParamIdx, JavaType.forObjectClass()); + } else { + mappedType = JavaType.forObjectClass(); + } + mb = mb.replaceJavaArgumentType(userParamIdx, mappedType); } } // Produce the method signature @@ -3124,6 +3134,8 @@ public class JavaEmitter implements GlueEmitter { if( cArgType.getTargetType().isVoid() ) { if( jcbi.cbFuncUserParamType.isCompound() ) { mappedType = JavaType.createForClass(long.class); + } else if( null != jcbi.userParamClassName ) { + mappedType = JavaType.createForNamedClass( jcbi.userParamClassName ); } else { mappedType = JavaType.forObjectClass(); } diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java b/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java index 90e01df..09b51c7 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java @@ -80,6 +80,27 @@ public class Test4JavaCallback extends BaseClass { dynamicLookupHelper = null; } + private static class MyUserParam01 { + final long i; + long j; + public MyUserParam01(final long i) { this.i = i; j=0; } + + @Override + public boolean equals(final Object o) { + if( this == o ) { + return true; + } + if( !(o instanceof MyUserParam01) ) { + return false; + } + return false; // we require identity! + } + @Override + public int hashCode() { + return System.identityHashCode(this); // we require identity! + } + } + /** * Test Bindingtest2 with T2_CallbackFunc JavaCallback */ @@ -169,17 +190,21 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(1+42+10+404+10, myUserParam01.j); } } - private static class MyUserParam01 { + + public static class ALCcontext { final long i; long j; - public MyUserParam01(final long i) { this.i = i; j=0; } + int buffer; + boolean throwPreAction, throwPostAction; + public ALCcontext(final long i) { this.i = i; j=0; buffer=0; throwPreAction=false; throwPostAction=false; } + public ALCcontext() { this.i = 0; j=0; buffer=0; throwPreAction=false; throwPostAction=false; } @Override public boolean equals(final Object o) { if( this == o ) { return true; } - if( !(o instanceof MyUserParam01) ) { + if( !(o instanceof ALCcontext) ) { return false; } return false; // we require identity! @@ -190,6 +215,7 @@ public class Test4JavaCallback extends BaseClass { } } + /** * Test Bindingtest2 with ALBUFFERCALLBACKTYPESOFT JavaCallback via alBufferCallback1() * using the default AlBufferCallback1Key class. @@ -201,23 +227,21 @@ public class Test4JavaCallback extends BaseClass { final long[] id_res = { -1 }; final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - final long res = sampledata + numbytes + myUserParam.i; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + final long res = sampledata + numbytes + context.i; id_res[0] = res; - myUserParam.j = res; - myUserParam.buffer = buffer; + context.j = res; + context.buffer = buffer; System.err.println("chapter02.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); } }; final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - final long res = sampledata * numbytes + myUserParam.i; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + final long res = sampledata * numbytes + context.i; id_res[0] = res; - myUserParam.j = res; - myUserParam.buffer = buffer; + context.j = res; + context.buffer = buffer; System.err.println("chapter02.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); } }; @@ -227,26 +251,26 @@ public class Test4JavaCallback extends BaseClass { final AlBufferCallback0Key buffer1Key = new AlBufferCallback0Key(buffer1); final AlBufferCallback0Key buffer2Key = new AlBufferCallback0Key(buffer2); final AlBufferCallback0Key buffer3Key = new AlBufferCallback0Key(buffer3); - final MyUserParam02 myUserParam01 = new MyUserParam02( 1); - final MyUserParam02 myUserParam02 = new MyUserParam02( 2); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals( 0, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + final ALCcontext context01 = new ALCcontext( 1); + final ALCcontext context02 = new ALCcontext( 2); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals( 0, context01.j); + Assert.assertEquals( 0, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); Assert.assertEquals(0, bt2.getAlBufferCallback0Keys().size()); - // 1st mapping: buffer1 -> myCallback01, myUserParam01 - bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, myUserParam01); + // 1st mapping: buffer1 -> myCallback01, context01 + bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, context01); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); @@ -260,13 +284,13 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(false, keys.contains(buffer3Key)); } - // 2nd mapping: buffer2 -> myCallback02, myUserParam02 - bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, myUserParam02); + // 2nd mapping: buffer2 -> myCallback02, context02 + bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, context02); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); Assert.assertEquals(myCallback02, bt2.getAlBufferCallback0(buffer2Key)); @@ -283,76 +307,76 @@ public class Test4JavaCallback extends BaseClass { final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01 } }); thread.start(); thread.join(); Assert.assertEquals(10+100+1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); } { - bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02 Assert.assertEquals(10*100+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } - // Switch the callback function for buffer2 -> myCallback01, myUserParam02 - bt2.alBufferCallback0(buffer2, 0, 0, myCallback01, myUserParam02); + // Switch the callback function for buffer2 -> myCallback01, context02 + bt2.alBufferCallback0(buffer2, 0, 0, myCallback01, context02); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3Key)); { - bt2.alBufferCallback0Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback0Inject(buffer1, 11, 101); // buffer1 -> myCallback01, context01 Assert.assertEquals(11+101+1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(11+101+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(11+101+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } { final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback0Inject(buffer2, 1, 10); // buffer2 -> myCallback01, myUserParam02 + bt2.alBufferCallback0Inject(buffer2, 1, 10); // buffer2 -> myCallback01, context02 } }); thread.start(); thread.join(); Assert.assertEquals( 1+ 10+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(11+101+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 1+ 10+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(11+101+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 1+ 10+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } // Just release the buffer2 callback and mapped resources - bt2.alBufferCallback0(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key! + bt2.alBufferCallback0(buffer2, 0, 0, null, context02); // usrptr is not key, only buffer is key! Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); @@ -366,13 +390,13 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(false, keys.contains(buffer3Key)); } - // Switch the callback function for buffer2 -> myCallback01, myUserParam02 + // Switch the callback function for buffer2 -> myCallback01, context02 { // pre-condition Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); @@ -380,13 +404,13 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3Key)); Assert.assertEquals(1, bt2.getAlBufferCallback0Keys().size()); } - bt2.alBufferCallback0(buffer1, 0, 0, myCallback02, myUserParam02); + bt2.alBufferCallback0(buffer1, 0, 0, myCallback02, context02); { // post-state Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback02, bt2.getAlBufferCallback0(buffer1Key)); @@ -394,18 +418,18 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3Key)); } { - myUserParam01.j = 0; - myUserParam01.buffer = 0; - myUserParam02.j = 0; - myUserParam02.buffer = 0; - bt2.alBufferCallback0Inject(buffer1, 2, 10); // buffer1 -> myCallback01, myUserParam01 + context01.j = 0; + context01.buffer = 0; + context02.j = 0; + context02.buffer = 0; + bt2.alBufferCallback0Inject(buffer1, 2, 10); // buffer1 -> myCallback01, context01 Assert.assertEquals( 2*10+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals( 0, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 2*10+2, myUserParam02.j); - Assert.assertEquals( 1, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals( 0, context01.j); + Assert.assertEquals( 0, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 2*10+2, context02.j); + Assert.assertEquals( 1, context02.buffer); } // Just release the buffer1 callback and mapped resources @@ -429,18 +453,18 @@ public class Test4JavaCallback extends BaseClass { { id_res[0] = 0; - myUserParam01.j = 0; - myUserParam01.buffer = 0; - myUserParam02.j = 0; - myUserParam02.buffer = 0; + context01.j = 0; + context01.buffer = 0; + context02.j = 0; + context02.buffer = 0; bt2.alBufferCallback0Inject(buffer2, 1, 10); // unmapped, no change in data Assert.assertEquals( 0, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals( 0, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals( 0, context01.j); + Assert.assertEquals( 0, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); } } @@ -455,23 +479,21 @@ public class Test4JavaCallback extends BaseClass { final long[] id_res = { -1 }; final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - final long res = sampledata + numbytes + myUserParam.i; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + final long res = sampledata + numbytes + context.i; id_res[0] = res; - myUserParam.j = res;; - myUserParam.buffer = buffer; + context.j = res;; + context.buffer = buffer; System.err.println("chapter03.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); } }; final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - final long res = sampledata * numbytes + myUserParam.i; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + final long res = sampledata * numbytes + context.i; id_res[0] = res; - myUserParam.j = res; - myUserParam.buffer = buffer; + context.j = res; + context.buffer = buffer; System.err.println("chapter03.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); } }; @@ -481,26 +503,26 @@ public class Test4JavaCallback extends BaseClass { final CustomAlBufferCallback1Key buffer1Key = new CustomAlBufferCallback1Key(buffer1); final CustomAlBufferCallback1Key buffer2Key = new CustomAlBufferCallback1Key(buffer2); final CustomAlBufferCallback1Key buffer3Key = new CustomAlBufferCallback1Key(buffer3); - final MyUserParam02 myUserParam01 = new MyUserParam02( 1); - final MyUserParam02 myUserParam02 = new MyUserParam02( 2); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals( 0, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + final ALCcontext context01 = new ALCcontext( 1); + final ALCcontext context02 = new ALCcontext( 2); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals( 0, context01.j); + Assert.assertEquals( 0, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key)); Assert.assertEquals(0, bt2.getAlBufferCallback1Keys().size()); - // 1st mapping: buffer1 -> myCallback01, myUserParam01 - bt2.alBufferCallback1(myUserParam01, buffer1, 0, 0, myCallback01); + // 1st mapping: buffer1 -> myCallback01, context01 + bt2.alBufferCallback1(context01, buffer1, 0, 0, myCallback01); Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1Key)); @@ -514,13 +536,13 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(false, keys.contains(buffer3Key)); } - // 2nd mapping: buffer2 -> myCallback02, myUserParam02 - bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, myCallback02); + // 2nd mapping: buffer2 -> myCallback02, context02 + bt2.alBufferCallback1(context02, buffer2, 0, 0, myCallback02); Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1Key)); Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback1UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1Key)); Assert.assertEquals(myCallback02, bt2.getAlBufferCallback1(buffer2Key)); @@ -534,40 +556,40 @@ public class Test4JavaCallback extends BaseClass { } { - bt2.alBufferCallback1Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback1Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01 Assert.assertEquals(10+100+1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); } { final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback1Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback1Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02 } }); thread.start(); thread.join(); Assert.assertEquals(10*100+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } - // Switch the callback function for buffer2 -> myCallback01, myUserParam02 - bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, myCallback01); + // Switch the callback function for buffer2 -> myCallback01, context02 + bt2.alBufferCallback1(context02, buffer2, 0, 0, myCallback01); Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1Key)); Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback1UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer2Key)); @@ -577,36 +599,36 @@ public class Test4JavaCallback extends BaseClass { final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback1Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback1Inject(buffer1, 11, 101); // buffer1 -> myCallback01, context01 } }); thread.start(); thread.join(); Assert.assertEquals(11+101+1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(11+101+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(11+101+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } { - bt2.alBufferCallback1Inject(buffer2, 1, 10); // buffer2 -> myCallback01, myUserParam02 + bt2.alBufferCallback1Inject(buffer2, 1, 10); // buffer2 -> myCallback01, context02 Assert.assertEquals( 1+ 10+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(11+101+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 1+ 10+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(11+101+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 1+ 10+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } // Just release the buffer2 callback and mapped resources - bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, null); // usrptr is not key, only buffer is key! + bt2.alBufferCallback1(context02, buffer2, 0, 0, null); // usrptr is not key, only buffer is key! Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1Key)); @@ -642,34 +664,12 @@ public class Test4JavaCallback extends BaseClass { { bt2.alBufferCallback1Inject(buffer2, 1, 10); // unmapped, no change in data Assert.assertEquals( 1+ 10+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(11+101+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 1+ 10+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); - } - } - private static class MyUserParam02 { - final long i; - long j; - int buffer; - boolean throwPreAction, throwPostAction; - public MyUserParam02(final long i) { this.i = i; j=0; buffer=0; throwPreAction=false; throwPostAction=false; } - - @Override - public boolean equals(final Object o) { - if( this == o ) { - return true; - } - if( !(o instanceof MyUserParam02) ) { - return false; - } - return false; // we require identity! - } - @Override - public int hashCode() { - return System.identityHashCode(this); // we require identity! + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(11+101+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 1+ 10+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } } @@ -684,38 +684,36 @@ public class Test4JavaCallback extends BaseClass { final long[] id_res = { -1 }; final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - if( myUserParam.throwPreAction ) { - myUserParam.throwPreAction = false; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + if( context.throwPreAction ) { + context.throwPreAction = false; throw new RuntimeException("Exception test.pre: chapter04.myCallback01"); } - final long res = sampledata + numbytes + myUserParam.i; + final long res = sampledata + numbytes + context.i; id_res[0] = res; - myUserParam.j = res; - myUserParam.buffer = buffer; + context.j = res; + context.buffer = buffer; System.err.println("chapter04.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); - if( myUserParam.throwPostAction ) { - myUserParam.throwPostAction = false; + if( context.throwPostAction ) { + context.throwPostAction = false; throw new RuntimeException("Exception test.post: chapter04.myCallback01"); } } }; final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() { @Override - public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) { - final MyUserParam02 myUserParam = (MyUserParam02)userptr; - if( myUserParam.throwPreAction ) { - myUserParam.throwPreAction = false; + public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) { + if( context.throwPreAction ) { + context.throwPreAction = false; throw new RuntimeException("Exception test.pre: chapter04.myCallback02"); } - final long res = sampledata * numbytes + myUserParam.i; + final long res = sampledata * numbytes + context.i; id_res[0] = res; - myUserParam.j = res; - myUserParam.buffer = buffer; + context.j = res; + context.buffer = buffer; System.err.println("chapter04.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); - if( myUserParam.throwPostAction ) { - myUserParam.throwPostAction = false; + if( context.throwPostAction ) { + context.throwPostAction = false; throw new RuntimeException("Exception test.post: chapter04.myCallback02"); } } @@ -726,26 +724,26 @@ public class Test4JavaCallback extends BaseClass { final AlBufferCallback0Key buffer1Key = new AlBufferCallback0Key(buffer1); final AlBufferCallback0Key buffer2Key = new AlBufferCallback0Key(buffer2); final AlBufferCallback0Key buffer3Key = new AlBufferCallback0Key(buffer3); - final MyUserParam02 myUserParam01 = new MyUserParam02( 1); - final MyUserParam02 myUserParam02 = new MyUserParam02( 2); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals( 0, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + final ALCcontext context01 = new ALCcontext( 1); + final ALCcontext context02 = new ALCcontext( 2); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals( 0, context01.j); + Assert.assertEquals( 0, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); Assert.assertEquals(0, bt2.getAlBufferCallback0Keys().size()); - // 1st mapping: buffer1 -> myCallback01, myUserParam01 - bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, myUserParam01); + // 1st mapping: buffer1 -> myCallback01, context01 + bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, context01); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); @@ -759,13 +757,13 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(false, keys.contains(buffer3Key)); } - // 2nd mapping: buffer2 -> myCallback02, myUserParam02 - bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, myUserParam02); + // 2nd mapping: buffer2 -> myCallback02, context02 + bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, context02); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); - Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); Assert.assertEquals(myCallback02, bt2.getAlBufferCallback0(buffer2Key)); @@ -782,75 +780,75 @@ public class Test4JavaCallback extends BaseClass { // Continuous program flow id_res[0] = -1; { - myUserParam01.throwPostAction = true; - bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01 + context01.throwPostAction = true; + bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01 Assert.assertEquals(10+100+1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals( 0, myUserParam02.j); - Assert.assertEquals( 0, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals( 0, context02.j); + Assert.assertEquals( 0, context02.buffer); } { - myUserParam02.throwPostAction = true; + context02.throwPostAction = true; final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02 } }); thread.start(); thread.join(); Assert.assertEquals(10*100+2, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } // Exception text pre action, i.e. result NOT as expected (unchanged) // Continuous program flow id_res[0] = -1; { - myUserParam01.throwPreAction = true; - bt2.alBufferCallback0Inject(buffer1, 20, 200); // buffer1 -> myCallback01, myUserParam01 + context01.throwPreAction = true; + bt2.alBufferCallback0Inject(buffer1, 20, 200); // buffer1 -> myCallback01, context01 Assert.assertEquals( -1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } { - myUserParam02.throwPreAction = true; + context02.throwPreAction = true; final Thread thread = new Thread(new Runnable() { @Override public void run() { - bt2.alBufferCallback0Inject(buffer2, 20, 200); // buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback0Inject(buffer2, 20, 200); // buffer2 -> myCallback02, context02 } }); thread.start(); thread.join(); Assert.assertEquals( -1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } // Just release the buffer2 callback and mapped resources bt2.releaseAlBufferCallback0(buffer2Key); - // bt2.alBufferCallback0(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key! + // bt2.alBufferCallback0(buffer2, 0, 0, null, context02); // usrptr is not key, only buffer is key! Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key)); Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key)); - Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key)); + Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2Key)); Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3Key)); Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1Key)); @@ -897,12 +895,12 @@ public class Test4JavaCallback extends BaseClass { id_res[0] = -1; bt2.alBufferCallback0Inject(buffer2, 1, 10); Assert.assertEquals( -1, id_res[0]); - Assert.assertEquals( 1, myUserParam01.i); - Assert.assertEquals(10+100+1, myUserParam01.j); - Assert.assertEquals( 1, myUserParam01.buffer); - Assert.assertEquals( 2, myUserParam02.i); - Assert.assertEquals(10*100+2, myUserParam02.j); - Assert.assertEquals( 2, myUserParam02.buffer); + Assert.assertEquals( 1, context01.i); + Assert.assertEquals(10+100+1, context01.j); + Assert.assertEquals( 1, context01.buffer); + Assert.assertEquals( 2, context02.i); + Assert.assertEquals(10*100+2, context02.j); + Assert.assertEquals( 2, context02.buffer); } public static class CustomAlBufferCallback1Key { @@ -943,30 +941,30 @@ public class Test4JavaCallback extends BaseClass { final String[] msg_res = { null }; final ALEVENTPROCSOFT myCallback01 = new ALEVENTPROCSOFT() { @Override - public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) { + public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) { id_res[0] = object; msg_res[0] = message; System.err.println("chapter05a.myCallback01: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+ - Integer.toHexString(System.identityHashCode(userParam))); + Integer.toHexString(System.identityHashCode(context))); } }; final ALEVENTPROCSOFT myCallback02 = new ALEVENTPROCSOFT() { @Override - public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) { + public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) { id_res[0] = 1000 * object; msg_res[0] = message; System.err.println("chapter05a.myCallback02: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+ - Integer.toHexString(System.identityHashCode(userParam))); + Integer.toHexString(System.identityHashCode(context))); } }; - final Object myUserParam01 = new Object(); - final Object myUserParam02 = new Object(); - final AlEventCallback0Key myKey01 = new AlEventCallback0Key(myUserParam01); - final AlEventCallback0Key myKey02 = new AlEventCallback0Key(myUserParam02); + final ALCcontext context01 = new ALCcontext(); + final ALCcontext context02 = new ALCcontext(); + final AlEventCallback0Key myKey01 = new AlEventCallback0Key(context01); + final AlEventCallback0Key myKey02 = new AlEventCallback0Key(context02); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02)); - bt2.alEventCallback0(myCallback01, myUserParam01); + bt2.alEventCallback0(myCallback01, context01); Assert.assertEquals(true, bt2.isAlEventCallback0Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02)); { @@ -984,7 +982,7 @@ public class Test4JavaCallback extends BaseClass { final String msgNo1 = "First message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback0Inject(myUserParam01, 0, 1, 0, msgNo1); + bt2.alEventCallback0Inject(context01, 0, 1, 0, msgNo1); Assert.assertEquals( 1, id_res[0]); Assert.assertEquals(msgNo1, msg_res[0]); } @@ -992,19 +990,19 @@ public class Test4JavaCallback extends BaseClass { final String msgNo2 = "Second message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback0Inject(myUserParam02, 0, 2, 0, msgNo2); + bt2.alEventCallback0Inject(context02, 0, 2, 0, msgNo2); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback0Inject(myUserParam01, 0, 2, 0, msgNo2); + bt2.alEventCallback0Inject(context01, 0, 2, 0, msgNo2); Assert.assertEquals( 2, id_res[0]); Assert.assertEquals( msgNo2, msg_res[0]); } // Switch the callback function - // The previously mapped myCallback01 (myUserParam01) gets released - // and remapped to myCallback02 + ( myUserParam01 )(key) - bt2.alEventCallback0(myCallback02, myUserParam01); + // The previously mapped myCallback01 (context01) gets released + // and remapped to myCallback02 + ( context01 )(key) + bt2.alEventCallback0(myCallback02, context01); Assert.assertEquals(true, bt2.isAlEventCallback0Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02)); { @@ -1020,22 +1018,22 @@ public class Test4JavaCallback extends BaseClass { final String msgNo3 = "Third message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback0Inject(myUserParam02, 0, 3, 0, msgNo3); + bt2.alEventCallback0Inject(context02, 0, 3, 0, msgNo3); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback0Inject(myUserParam01, 0, 3, 0, msgNo3); + bt2.alEventCallback0Inject(context01, 0, 3, 0, msgNo3); Assert.assertEquals( 3000, id_res[0]); Assert.assertEquals( msgNo3, msg_res[0]); } // Fake release (wrong key) - bt2.alEventCallback0(null, myUserParam02); + bt2.alEventCallback0(null, context02); Assert.assertEquals(true, bt2.isAlEventCallback0Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02)); - // Just release the callback and mapped myUserParam01 - bt2.alEventCallback0(null, myUserParam01); + // Just release the callback and mapped context01 + bt2.alEventCallback0(null, context01); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02)); Assert.assertEquals(0, bt2.getAlEventCallback0Keys().size()); @@ -1044,11 +1042,11 @@ public class Test4JavaCallback extends BaseClass { final String msgNo4 = "Forth message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback0Inject(myUserParam01, 0, 4, 0, msgNo4); + bt2.alEventCallback0Inject(context01, 0, 4, 0, msgNo4); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback0Inject(myUserParam02, 0, 4, 0, msgNo4); + bt2.alEventCallback0Inject(context02, 0, 4, 0, msgNo4); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); } @@ -1066,30 +1064,30 @@ public class Test4JavaCallback extends BaseClass { final String[] msg_res = { null }; final ALEVENTPROCSOFT myCallback01 = new ALEVENTPROCSOFT() { @Override - public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) { + public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) { id_res[0] = object; msg_res[0] = message; System.err.println("chapter05.myCallback01: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+ - Integer.toHexString(System.identityHashCode(userParam))); + Integer.toHexString(System.identityHashCode(context))); } }; final ALEVENTPROCSOFT myCallback02 = new ALEVENTPROCSOFT() { @Override - public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) { + public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) { id_res[0] = 1000 * object; msg_res[0] = message; System.err.println("chapter05.myCallback02: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+ - Integer.toHexString(System.identityHashCode(userParam))); + Integer.toHexString(System.identityHashCode(context))); } }; - final Object myUserParam01 = new Object(); - final Object myUserParam02 = new Object(); - final AlEventCallback1Key myKey01 = new AlEventCallback1Key(1, myUserParam01); - final AlEventCallback1Key myKey02 = new AlEventCallback1Key(2, myUserParam02); + final ALCcontext context01 = new ALCcontext(); + final ALCcontext context02 = new ALCcontext(); + final AlEventCallback1Key myKey01 = new AlEventCallback1Key(1, context01); + final AlEventCallback1Key myKey02 = new AlEventCallback1Key(2, context02); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); - bt2.alEventCallback1(1, myCallback01, myUserParam01); + bt2.alEventCallback1(1, myCallback01, context01); Assert.assertEquals(true, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); { @@ -1107,7 +1105,7 @@ public class Test4JavaCallback extends BaseClass { final String msgNo1 = "First message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo1); + bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo1); Assert.assertEquals( 1, id_res[0]); Assert.assertEquals(msgNo1, msg_res[0]); } @@ -1115,23 +1113,23 @@ public class Test4JavaCallback extends BaseClass { final String msgNo2 = "Second message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback1Inject(myUserParam02, 0, 2, 0, msgNo2); + bt2.alEventCallback1Inject(context02, 0, 2, 0, msgNo2); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback1Inject(myUserParam01, 0, 2, 0, msgNo2); + bt2.alEventCallback1Inject(context01, 0, 2, 0, msgNo2); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo2); + bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo2); Assert.assertEquals( 1, id_res[0]); Assert.assertEquals( msgNo2, msg_res[0]); } // Switch the callback function - // The previously mapped myCallback01 (1, myUserParam01) gets released - // and remapped to myCallback02 + ( 1, myUserParam01 )(key) - bt2.alEventCallback1(1, myCallback02, myUserParam01); + // The previously mapped myCallback01 (1, context01) gets released + // and remapped to myCallback02 + ( 1, context01 )(key) + bt2.alEventCallback1(1, myCallback02, context01); Assert.assertEquals(true, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); { @@ -1147,30 +1145,30 @@ public class Test4JavaCallback extends BaseClass { final String msgNo3 = "Third message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback1Inject(myUserParam02, 0, 2, 0, msgNo3); + bt2.alEventCallback1Inject(context02, 0, 2, 0, msgNo3); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback1Inject(myUserParam01, 0, 2, 0, msgNo3); + bt2.alEventCallback1Inject(context01, 0, 2, 0, msgNo3); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo3); + bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo3); Assert.assertEquals( 1000, id_res[0]); Assert.assertEquals( msgNo3, msg_res[0]); } // Fake release (wrong key) - bt2.alEventCallback1(2, null, myUserParam02); + bt2.alEventCallback1(2, null, context02); Assert.assertEquals(true, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); - bt2.alEventCallback1(2, null, myUserParam01); + bt2.alEventCallback1(2, null, context01); Assert.assertEquals(true, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); - // Just release the callback and mapped myUserParam01 - bt2.alEventCallback1(1, null, myUserParam01); + // Just release the callback and mapped context01 + bt2.alEventCallback1(1, null, context01); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey01)); Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02)); Assert.assertEquals(0, bt2.getAlEventCallback1Keys().size()); @@ -1179,11 +1177,11 @@ public class Test4JavaCallback extends BaseClass { final String msgNo4 = "Forth message"; id_res[0] = -1; msg_res[0] = null; - bt2.alEventCallback1Inject(myUserParam01, 0, 4, 0, msgNo4); + bt2.alEventCallback1Inject(context01, 0, 4, 0, msgNo4); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); - bt2.alEventCallback1Inject(myUserParam02, 0, 4, 0, msgNo4); + bt2.alEventCallback1Inject(context02, 0, 4, 0, msgNo4); Assert.assertEquals( -1, id_res[0]); Assert.assertEquals( null, msg_res[0]); } diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub index 28d46a6..2242d4c 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub @@ -1,4 +1,4 @@ - public void alEventCallback0Inject(Object userParam, int eventType, int object, int param, String message); + public void alEventCallback0Inject(ALCcontext userParam, int eventType, int object, int param, String message); - public void alEventCallback1Inject(Object userParam, int eventType, int object, int param, String message); + public void alEventCallback1Inject(ALCcontext userParam, int eventType, int object, int param, String message); diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub index 6643108..9d58e02 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub @@ -1,10 +1,10 @@ - public void alEventCallback0Inject(Object userParam, int eventType, int object, int param, String message) { - final Object userParam2; + public void alEventCallback0Inject(ALCcontext userParam, int eventType, int object, int param, String message) { + final ALCcontext userParam2; final AlEventCallback0Data value; synchronized( alEventCallback0Lock ) { final AlEventCallback0Data value0 = alEventCallback0DataMap.get( new AlEventCallback0Key( userParam ) ); if( null != value0 ) { - userParam2 = alEventCallback0UserObjIDMap.get(value0.paramID); + userParam2 = (ALCcontext) alEventCallback0UserObjIDMap.get(value0.paramID); if( userParam != userParam2 ) { throw new InternalError("Impl issue-1: Arg userParam "+userParam+" != "+userParam2); } @@ -21,13 +21,13 @@ value.func.callback(eventType, object, param, message.length(), message, userParam2); } - public void alEventCallback1Inject(Object userParam, int eventType, int object, int param, String message) { - final Object userParam2; + public void alEventCallback1Inject(ALCcontext userParam, int eventType, int object, int param, String message) { + final ALCcontext userParam2; final AlEventCallback1Data value; synchronized( alEventCallback1Lock ) { final AlEventCallback1Data value0 = alEventCallback1DataMap.get( new AlEventCallback1Key( object, userParam ) ); if( null != value0 ) { - userParam2 = alEventCallback1UserObjIDMap.get(value0.paramID); + userParam2 = (ALCcontext) alEventCallback1UserObjIDMap.get(value0.paramID); if( userParam != userParam2 ) { throw new InternalError("Impl issue-1: Arg userParam "+userParam+" != "+userParam2); } diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg index 3a1c7b3..fdad264 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg @@ -94,10 +94,10 @@ JavaCallbackDef MessageCallback01 1 T2_CallbackFunc01 2 # - `Set getAlBufferCallback0Keys()` returns set of Key { int buffer } # - `boolean isAlBufferCallback0Mapped(AlBufferCallback0Key)` queries whether `alBufferCallback0` is mapped to `buffer`. # - `ALBUFFERCALLBACKTYPESOFT getAlBufferCallback0(AlBufferCallback0Key)` returns the `buffer` mapped ALEVENTPROCSOFT, null if not mapped -# - `Object getAlBufferCallback0UserParam(AlBufferCallback0Key)` returns the `buffer` mapped `userptr` object, null if not mapped +# - `ALCcontext getAlBufferCallback0UserParam(AlBufferCallback0Key)` returns the `buffer` mapped `userptr` object, null if not mapped # - `void releaseAllAlBufferCallback0()` releases all callback data mapped via Key { int buffer } skipping toolkit API. Favor passing `null` callback ref to `alBufferCallback0(..)` # - `void releaseAlBufferCallback0(AlBufferCallback0Key)` releases callback data mapped to Key { int buffer } skipping toolkit API. Favor passing `null` callback ref to `alBufferCallback0(..)` -JavaCallbackDef alBufferCallback0 4 ALBUFFERCALLBACKTYPESOFT 1 +JavaCallbackDef alBufferCallback0 4 ALBUFFERCALLBACKTYPESOFT 1 ALCcontext JavaCallbackKey alBufferCallback0 0 ALBUFFERCALLBACKTYPESOFT 0 # # End JavaCallback @@ -126,8 +126,8 @@ JavaCallbackKey alBufferCallback0 0 ALBUFFERCALLBACKTYPESOFT 0 # Explicit maintenance methods are generated, passing the keys as paramters # - `boolean isAlBufferCallback1Mapped(int buffer)` queries whether `alBufferCallback1` is mapped to `buffer`. # - `ALBUFFERCALLBACKTYPESOFT getAlBufferCallback1(int buffer)` returns the `buffer` mapped ALEVENTPROCSOFT, null if not mapped -# - `Object getAlBufferCallback1UserParam(int buffer)` returns the `buffer` mapped `userptr` object, null if not mapped -JavaCallbackDef alBufferCallback1 0 ALBUFFERCALLBACKTYPESOFT 1 com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomAlBufferCallback1Key +# - `ALCcontext getAlBufferCallback1UserParam(int buffer)` returns the `buffer` mapped `userptr` object, null if not mapped +JavaCallbackDef alBufferCallback1 0 ALBUFFERCALLBACKTYPESOFT 1 ALCcontext com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomAlBufferCallback1Key JavaCallbackKey alBufferCallback1 1 ALBUFFERCALLBACKTYPESOFT 0 # # End JavaCallback @@ -146,7 +146,7 @@ ArgumentIsPascalString ALEVENTPROCSOFT 3 4 # and marks `ALEVENTPROCSOFT`s 6th argument (index 5) as the mandatory user-param. # # This callback uses 'Object userParam' as its key (for a context), similar to `AL_SOFT_events` context binding. -JavaCallbackDef alEventCallback0 1 ALEVENTPROCSOFT 5 +JavaCallbackDef alEventCallback0 1 ALEVENTPROCSOFT 5 ALCcontext JavaCallbackKey alEventCallback0 1 ALEVENTPROCSOFT 5 # # End JavaCallback @@ -154,7 +154,7 @@ JavaCallbackKey alEventCallback0 1 ALEVENTPROCSOFT 5 # Begin JavaCallback. # # void alEventCallback1(int object /* key */, ALEVENTPROCSOFT callback, void *userParam /* key */); -JavaCallbackDef alEventCallback1 2 ALEVENTPROCSOFT 5 +JavaCallbackDef alEventCallback1 2 ALEVENTPROCSOFT 5 ALCcontext JavaCallbackKey alEventCallback1 0 2 ALEVENTPROCSOFT 1 5 # @@ -168,7 +168,7 @@ IncludeAs CustomJavaCode Bindingtest2Impl test2-CustomJavaImplCode.java.stub # typedef void ( * T2_CallbackFunc11)(size_t id, const T2_Callback11UserType* usrParam); # void MessageCallback11a(size_t id /* key */, T2_CallbackFunc11 cbFunc, const T2_Callback11UserType* usrParam); # void MessageCallback11aInject(size_t id); -#JavaCallbackDef MessageCallback11a T2_CallbackFunc11 1 com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomMessageCallback11Key +#JavaCallbackDef MessageCallback11a T2_CallbackFunc11 1 Object com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomMessageCallback11Key JavaCallbackDef MessageCallback11a 2 T2_CallbackFunc11 1 JavaCallbackKey MessageCallback11a 0 T2_CallbackFunc11 0 # @@ -187,6 +187,7 @@ Import com.jogamp.gluegen.test.junit.generation.T2_InitializeOptions Import com.jogamp.gluegen.test.junit.generation.T2_ThreadAffinity Import com.jogamp.gluegen.test.junit.generation.T2_UserData Import com.jogamp.gluegen.test.junit.generation.T2_Callback11UserType +Import com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.ALCcontext CustomJavaCode Bindingtest2Impl private static Bindingtest2ProcAddressTable _table = new Bindingtest2ProcAddressTable(); CustomJavaCode Bindingtest2Impl public static void resetProcAddressTable(DynamicLookupHelper lookup) { -- cgit v1.2.3