diff options
Diffstat (limited to 'src/junit/com/jogamp/gluegen')
4 files changed, 597 insertions, 26 deletions
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 e80be6f..e43d73e 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java @@ -31,6 +31,7 @@ package com.jogamp.gluegen.test.junit.generation; import java.io.IOException; import com.jogamp.common.os.NativeLibrary; +import com.jogamp.gluegen.test.junit.generation.Bindingtest2.ALBUFFERCALLBACKTYPESOFT; import com.jogamp.gluegen.test.junit.generation.Bindingtest2.T2_CallbackFunc01; import com.jogamp.gluegen.test.junit.generation.impl.Bindingtest2Impl; @@ -83,30 +84,30 @@ public class Test4JavaCallback extends BaseClass { final T2_CallbackFunc01 myCallback01 = new T2_CallbackFunc01() { @Override public void callback(final long id, final String msg, final Object userParam) { - final MyUserParam myUserParam = (MyUserParam)userParam; + final MyUserParam01 myUserParam = (MyUserParam01)userParam; id_res[0] = id + myUserParam.i; msg_res[0] = msg; myUserParam.j += id_res[0]; - System.err.println("chapter10.myCallback01: "+id+", '"+msg+"'"); + System.err.println("chapter01.myCallback01: "+id+", '"+msg+"'"); } }; final T2_CallbackFunc01 myCallback02 = new T2_CallbackFunc01() { @Override public void callback(final long id, final String msg, final Object userParam) { - final MyUserParam myUserParam = (MyUserParam)userParam; + final MyUserParam01 myUserParam = (MyUserParam01)userParam; id_res[0] = id; msg_res[0] = msg; myUserParam.j += id_res[0]; - System.err.println("chapter10.myCallback02: "+id+", '"+msg+"'"); + System.err.println("chapter01.myCallback02: "+id+", '"+msg+"'"); } }; - final MyUserParam myUserParam01 = new MyUserParam(10); + final MyUserParam01 myUserParam01 = new MyUserParam01(10); Assert.assertEquals(10, myUserParam01.i); Assert.assertEquals( 0, myUserParam01.j); - Assert.assertEquals(false, bt2.isMessageCallback01Mapped(myUserParam01)); + Assert.assertEquals(false, bt2.isMessageCallback01Mapped()); bt2.MessageCallback01(myCallback01, myUserParam01); - Assert.assertEquals(true, bt2.isMessageCallback01Mapped(myUserParam01)); + Assert.assertEquals(true, bt2.isMessageCallback01Mapped()); Assert.assertEquals(-1, id_res[0]); Assert.assertEquals(null, msg_res[0]); Assert.assertEquals(10, myUserParam01.i); @@ -132,7 +133,7 @@ public class Test4JavaCallback extends BaseClass { // Switch the callback function // The previously mapped myUserParam01 gets released and remapped to new callback bt2.MessageCallback01(myCallback02, myUserParam01); - Assert.assertEquals(true, bt2.isMessageCallback01Mapped(myUserParam01)); + Assert.assertEquals(true, bt2.isMessageCallback01Mapped()); Assert.assertEquals( 42+10, id_res[0]); Assert.assertEquals( msgNo2, msg_res[0]); Assert.assertEquals( 10, myUserParam01.i); @@ -149,7 +150,7 @@ public class Test4JavaCallback extends BaseClass { // Just release the callback and mapped myUserParam01 bt2.MessageCallback01(null, myUserParam01); - Assert.assertEquals(false, bt2.isMessageCallback01Mapped(myUserParam01)); + Assert.assertEquals(false, bt2.isMessageCallback01Mapped()); { final String msgNo4 = "My Fourth JavaCallback message"; bt2.InjectMessageCallback01( 21, msgNo4); @@ -160,11 +161,392 @@ public class Test4JavaCallback extends BaseClass { Assert.assertEquals(1+42+10+404+10, myUserParam01.j); } } - private static class MyUserParam { + private static class MyUserParam01 { final long i; long j; - public MyUserParam(final long i) { this.i = i; j=0; } + 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 ALBUFFERCALLBACKTYPESOFT JavaCallback via alBufferCallback1() + * using the default AlBufferCallback1Key class. + */ + @Test + public void chapter02() throws Exception { + final Bindingtest2 bt2 = new Bindingtest2Impl(); + + 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; + id_res[0] = sampledata + numbytes + myUserParam.i; + myUserParam.j = id_res[0]; + myUserParam.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; + id_res[0] = sampledata * numbytes + myUserParam.i; + myUserParam.j = id_res[0]; + myUserParam.buffer = buffer; + System.err.println("chapter02.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); + } + }; + final int buffer1 = 1; + final int buffer2 = 2; + final int buffer3 = 3; + 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); + + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + + // 1st mapping: buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, myUserParam01); + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3)); + + // 2nd mapping: buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, myUserParam02); + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1)); + Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1)); + Assert.assertEquals(myCallback02, bt2.getAlBufferCallback0(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3)); + + { + bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01 + 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); + } + { + bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02 + 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); + } + + // Switch the callback function for buffer2 -> myCallback01, myUserParam02 + bt2.alBufferCallback0(buffer2, 0, 0, myCallback01, myUserParam02); + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1)); + Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3)); + + { + bt2.alBufferCallback0Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01 + 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); + } + { + bt2.alBufferCallback0Inject(buffer2, 1, 10); // buffer2 -> myCallback01, myUserParam02 + 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); + } + + // Just release the buffer2 callback and mapped resources + bt2.alBufferCallback0(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key! + Assert.assertEquals(true, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback0(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3)); + + // Just release the buffer1 callback and mapped resources + bt2.alBufferCallback0(buffer1, 0, 0, null, null); // usrptr is not key, only buffer is key! + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0UserParam(buffer3)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback0(buffer3)); + + { + bt2.alBufferCallback0Inject(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); + } + } + + /** + * Test Bindingtest2 with ALBUFFERCALLBACKTYPESOFT JavaCallback via alBufferCallback1() + * using our custom CustomAlBufferCallback1Key class. + */ + @Test + public void chapter03() throws Exception { + final Bindingtest2 bt2 = new Bindingtest2Impl(); + + 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; + id_res[0] = sampledata + numbytes + myUserParam.i; + myUserParam.j = id_res[0]; + myUserParam.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; + id_res[0] = sampledata * numbytes + myUserParam.i; + myUserParam.j = id_res[0]; + myUserParam.buffer = buffer; + System.err.println("chapter03.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes); + } + }; + final int buffer1 = 1; + final int buffer2 = 2; + final int buffer3 = 3; + 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); + + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + + // 1st mapping: buffer1 -> myCallback01, myUserParam01 + bt2.alBufferCallback1(buffer1, 0, 0, myCallback01, myUserParam01); + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer3)); + + // 2nd mapping: buffer2 -> myCallback02, myUserParam02 + bt2.alBufferCallback1(buffer2, 0, 0, myCallback02, myUserParam02); + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1)); + Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1)); + Assert.assertEquals(myCallback02, bt2.getAlBufferCallback1(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer3)); + + { + bt2.alBufferCallback1Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01 + 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); + } + { + bt2.alBufferCallback1Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02 + 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); + } + + // Switch the callback function for buffer2 -> myCallback01, myUserParam02 + bt2.alBufferCallback1(buffer2, 0, 0, myCallback01, myUserParam02); + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1)); + Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer3)); + + { + bt2.alBufferCallback1Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01 + 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); + } + { + bt2.alBufferCallback1Inject(buffer2, 1, 10); // buffer2 -> myCallback01, myUserParam02 + 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); + } + + // Just release the buffer2 callback and mapped resources + bt2.alBufferCallback1(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key! + Assert.assertEquals(true, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3)); + Assert.assertEquals(myCallback01, bt2.getAlBufferCallback1(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer3)); + + // Just release the buffer1 callback and mapped resources + bt2.alBufferCallback1(buffer1, 0, 0, null, null); // usrptr is not key, only buffer is key! + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer1)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2)); + Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1UserParam(buffer3)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer1)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer2)); + Assert.assertEquals(null, bt2.getAlBufferCallback1(buffer3)); + + { + 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; + public MyUserParam02(final long i) { this.i = i; j=0; buffer=0; } + + @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! + } + } + + public static class CustomAlBufferCallback1Key { + private final int buffer; + public CustomAlBufferCallback1Key(final int buffer) { + this.buffer = buffer; + } + @Override + public boolean equals(final Object o) { + if( this == o ) { + return true; + } + if( !(o instanceof CustomAlBufferCallback1Key) ) { + return false; + } + final CustomAlBufferCallback1Key o2 = (CustomAlBufferCallback1Key)o; + return buffer == o2.buffer; + } + @Override + public int hashCode() { + return buffer; + } + @Override + public String toString() { + return "CustomALKey[this "+toHexString(System.identityHashCode(this))+", buffer "+buffer+"]"; + } } + static private String toHexString(final int v) { return "0x"+Integer.toHexString(v); } public static void main(final String args[]) throws IOException { final String tstname = Test4JavaCallback.class.getName(); diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.c b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.c index 9715f11..7a7cb43 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.c +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.c @@ -86,6 +86,10 @@ int Release(T2_InitializeOptions* Options) { Options->CustomFuncB2 = NULL; } +// +// +// + static T2_CallbackFunc01 t2_callback01 = NULL; static void* t2_callback01_userparam = NULL; @@ -104,3 +108,79 @@ void InjectMessageCallback01(size_t id, const char* msg) { } } +// +// +// + +static ALEVENTPROCSOFT alEventCallback_cb = NULL; +static void* alEventCallback_up = NULL; + +void alEventCallback(ALEVENTPROCSOFT callback, void *userParam) { + alEventCallback_cb = callback; + alEventCallback_up = userParam; +} +void alEventCallbackInject(int eventType, int object, int param, const char* msg) { + if( NULL != alEventCallback_cb ) { + fprintf(stderr, "XXX InjectMessageCallback01 func %p, user %p\n", alEventCallback_cb, alEventCallback_up); + fflush(NULL); + (*alEventCallback_cb)(eventType, object, param, strlen(msg), msg, alEventCallback_up); + } +} + +// +// +// + +static const int MAX_AL_BUFFER = 5; +static ALBUFFERCALLBACKTYPESOFT alBufferCallback0_callback[] = { NULL, NULL, NULL, NULL, NULL }; +static void* alBufferCallback0_userptr[] = { NULL, NULL, NULL, NULL, NULL }; + +void alBufferCallback0(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr) { + if( buffer < 0 || MAX_AL_BUFFER <= buffer ) { + fprintf(stderr, "Error: alBufferCallback0: buffer not in range [0..%d), is %d\n", MAX_AL_BUFFER, buffer); + } else { + alBufferCallback0_callback[buffer] = callback; + alBufferCallback0_userptr[buffer] = userptr; + fprintf(stderr, "XXX alBufferCallback0 buffer %d -> func %p, user %p\n", buffer, callback, userptr); + } + fflush(NULL); +} +void alBufferCallback0Inject(int buffer, int sampledata, int numbytes) { + if( buffer < 0 || MAX_AL_BUFFER <= buffer ) { + fprintf(stderr, "Error: alBufferCallback0Inject: buffer not in range [0..%d), is %d\n", MAX_AL_BUFFER, buffer); + } + if( NULL != alBufferCallback0_callback[buffer] ) { + fprintf(stderr, "XXX alBufferCallback0Inject: buffer %d, func %p, user %p\n", buffer, alBufferCallback0_callback[buffer], alBufferCallback0_userptr[buffer]); + fflush(NULL); + (*alBufferCallback0_callback[buffer])(buffer, alBufferCallback0_userptr[buffer], sampledata, numbytes); + } +} + +// +// +// + +static ALBUFFERCALLBACKTYPESOFT alBufferCallback1_callback[] = { NULL, NULL, NULL, NULL, NULL }; +static void* alBufferCallback1_userptr[] = { NULL, NULL, NULL, NULL, NULL }; + +void alBufferCallback1(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr) { + if( buffer < 0 || MAX_AL_BUFFER <= buffer ) { + fprintf(stderr, "Error: alBufferCallback1: buffer not in range [0..%d), is %d\n", MAX_AL_BUFFER, buffer); + } else { + alBufferCallback1_callback[buffer] = callback; + alBufferCallback1_userptr[buffer] = userptr; + fprintf(stderr, "XXX alBufferCallback1 buffer %d -> func %p, user %p\n", buffer, callback, userptr); + } + fflush(NULL); +} +void alBufferCallback1Inject(int buffer, int sampledata, int numbytes) { + if( buffer < 0 || MAX_AL_BUFFER <= buffer ) { + fprintf(stderr, "Error: alBufferCallback1Inject: buffer not in range [0..%d), is %d\n", MAX_AL_BUFFER, buffer); + } + if( NULL != alBufferCallback1_callback[buffer] ) { + fprintf(stderr, "XXX alBufferCallback1Inject: buffer %d, func %p, user %p\n", buffer, alBufferCallback1_callback[buffer], alBufferCallback1_userptr[buffer]); + fflush(NULL); + (*alBufferCallback1_callback[buffer])(buffer, alBufferCallback1_userptr[buffer], sampledata, numbytes); + } +} + 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 94ea0af..de713cf 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg @@ -55,24 +55,111 @@ ArgumentIsString T2_CallbackFunc01 1 ArgumentIsString InjectMessageCallback01 1 # Define a JavaCallback. -# Set JavaCallback via function `MessageCallback01` if `T2_CallbackFunc01` argument is non-null, otherwise removes the callback and associated resources. -# It uses `usrParam` as the resource-key to map to the hidden native-usrParam object, -# hence a matching 'usrParam' must be passed for setting and removal of the callback. +# Set JavaCallback via function `MessageCallback01` if `T2_CallbackFunc01` argument is non-null, otherwise removes the mapped callback and associated resources. # # It uses the function-pointer argument `T2_CallbackFunc01` as the callback function type -# and marks `T2_CallbackFunc01`s 3rd argument (index 2) as the mandatory user-param for Java Object mapping. +# and marks `T2_CallbackFunc01`s 3rd argument (index 2) as the mandatory user-param. # -# Note: An explicit `isMessageCallback01Mapped(Object usrParam)` is being created to explicitly query whether `usrParam` maps to the associated resources. +# This callback has no keys defines, rendering it of global scope! +# +# Explicit queries are generated, passing the keys as paramters +# - `boolean isMessageCallback01Mapped()` queries whether `MessageCallback0` is mapped globally +# - `T2_CallbackFunc01 getMessageCallback01()` returns the global T2_CallbackFunc01, null if not mapped +# - `Object getMessageCallback01UserParam()` returns the global `usrParam` object, null if not mapped JavaCallbackDef MessageCallback01 T2_CallbackFunc01 2 +# +# End JavaCallback +# Begin JavaCallback. +# +# typedef void ( * ALEVENTPROCSOFT)(int eventType, int object, int param, int length, const char *message, void *userParam); +# void alEventCallback(ALEVENTPROCSOFT callback, void *userParam /* identity-key */); +# void alEventCallbackInject(int eventType, int object, int param, const char* msg); +ArgumentIsString ALEVENTPROCSOFT 4 +ArgumentIsString alEventCallbackInject 3 + +# Define a JavaCallback (OpenAL AL_SOFT_events) +# Set JavaCallback via function `alEventCallback` if `ALEVENTPROCSOFT` argument is non-null, otherwise removes the mapped callback and associated resources. +# +# It uses the function-pointer argument `ALEVENTPROCSOFT` as the callback function type +# and marks `ALEVENTPROCSOFT`s 6th argument (index 5) as the mandatory user-param. +# +# This callback has no keys defines, rendering it of global scope! +# The global key-less scope matches `AL_SOFT_events` semantics. +# +# Explicit queries are generated, passing the keys as paramters +# - `boolean isAlEventCallbackMapped()` queries whether `alEventCallback` is mapped globally +# - `ALEVENTPROCSOFT getAlEventCallback()` returns the global ALEVENTPROCSOFT, null if not mapped +# - `Object getAlEventCallbackUserParam()` returns the global `userParam` object, null if not mapped +JavaCallbackDef alEventCallback ALEVENTPROCSOFT 5 +JavaCallbackKey alEventCallback # # End JavaCallback -# typedef void ( * T2_CallbackFunc02)(const T2_Callback02UserType* usrParam); -# void MessageCallback02(T2_CallbackFunc02 cbFunc, const T2_Callback02UserType* usrParam); -# void InjectMessageCallback02(size_t id, const char* msg); -ArgumentIsString InjectMessageCallback02 1 -JavaCallbackDef MessageCallback02 T2_CallbackFunc02 0 +# Begin JavaCallback (OpanAL AL_SOFT_callback_buffer) +# +# // typedef void ( * ALBUFFERCALLBACKTYPESOFT)(int buffer, void *userptr, void *sampledata, int numbytes); +# typedef void ( * ALBUFFERCALLBACKTYPESOFT)(int buffer, void *userptr, int sampledata, int numbytes); +# +# void alBufferCallback0(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr /* identity-key */); +# +# // void alBufferCallback0Inject(int buffer, void *sampledata, int numbytes); +# void alBufferCallback0Inject(int buffer, int sampledata, int numbytes); + +# Define a JavaCallback. +# Set JavaCallback via function `alBufferCallback0` if `ALBUFFERCALLBACKTYPESOFT` argument is non-null, otherwise removes the mapped callback and associated resources. +# +# It uses the function-pointer argument `ALBUFFERCALLBACKTYPESOFT` as the callback function type +# and marks `ALBUFFERCALLBACKTYPESOFT`s 2nd argument (index 1) as the mandatory user-param. +# +# This callback defines one key, `buffer`, index 0 of alBufferCallback0(..) parameter list, limiting it to buffer-name scope! +# The `buffer` key allows setting one callback per buffer-name, compatible with the `AL_SOFT_callback_buffer` spec. +# +# Explicit queries are generated, passing the keys as paramters +# - `boolean isAlBufferCallback0Mapped(int buffer)` queries whether `alBufferCallback0` is mapped to `buffer`. +# - `ALBUFFERCALLBACKTYPESOFT getAlBufferCallback0(int buffer)` returns the `buffer` mapped ALEVENTPROCSOFT, null if not mapped +# - `Object getAlBufferCallback0UserParam(int buffer)` returns the `buffer` mapped `userptr` object, null if not mapped +JavaCallbackDef alBufferCallback0 ALBUFFERCALLBACKTYPESOFT 1 +JavaCallbackKey alBufferCallback0 0 +# +# End JavaCallback + +# Begin JavaCallback (OpanAL AL_SOFT_callback_buffer, variant 2) +# +# Reuses: ALBUFFERCALLBACKTYPESOFT, see above. +# +# void alBufferCallback1(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr /* identity-key */); +# +# // void alBufferCallback1Inject(int buffer, void *sampledata, int numbytes); +# void alBufferCallback1Inject(int buffer, int sampledata, int numbytes); + +# Define a JavaCallback. +# Set JavaCallback via function `alBufferCallback1` if `ALBUFFERCALLBACKTYPESOFT` argument is non-null, otherwise removes the mapped callback and associated resources. +# +# It uses the function-pointer argument `ALBUFFERCALLBACKTYPESOFT` as the callback function type +# and marks `ALBUFFERCALLBACKTYPESOFT`s 2nd argument (index 1) as the mandatory user-param. +# +# This callback defines one key, `buffer`, index 0 of alBufferCallback1(..) parameter list, limiting it to buffer-name scope! +# The `buffer` key allows setting one callback per buffer-name, compatible with the `AL_SOFT_callback_buffer` spec. +# +# Explicit queries 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 ALBUFFERCALLBACKTYPESOFT 1 com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomAlBufferCallback1Key +JavaCallbackKey alBufferCallback1 0 +# +# End JavaCallback + +# Begin JavaCallback +# +# typedef void ( * T2_CallbackFunc11)(const T2_Callback11UserType* usrParam); +# void MessageCallback11(T2_CallbackFunc11 cbFunc, const T2_Callback11UserType* usrParam); +# void InjectMessageCallback11(size_t id, const char* msg); +ArgumentIsString InjectMessageCallback11 1 +JavaCallbackDef MessageCallback11 T2_CallbackFunc11 0 +# +# End JavaCallback CustomCCode #include "test2.h" diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.h b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.h index afe94a5..d067390 100644 --- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.h +++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.h @@ -67,15 +67,37 @@ void MessageCallback01(T2_CallbackFunc01 cbFunc, void* usrParam); void InjectMessageCallback01(size_t id, const char* msg); // -// T2_CallbackFunc02 +// ALEVENTPROCSOFT (similar to OpenAL's AL_SOFT_events) +// +typedef void ( * ALEVENTPROCSOFT)(int eventType, int object, int param, int length, const char *message, void *userParam); + +void alEventCallback(ALEVENTPROCSOFT callback, void *userParam); +void alEventCallbackInject(int eventType, int object, int param, const char* msg); + +// +// ALBUFFERCALLBACKTYPESOFT (similar to OpenAL's AL_SOFT_callback_buffer) +// +// typedef void ( * ALBUFFERCALLBACKTYPESOFT)(int buffer, void *userptr, void *sampledata, int numbytes); +typedef void ( * ALBUFFERCALLBACKTYPESOFT)(int buffer, void *userptr, int sampledata, int numbytes); + +void alBufferCallback0(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr); +// void alBufferCallback0Inject(int buffer, void *sampledata, int numbytes); +void alBufferCallback0Inject(int buffer, int sampledata, int numbytes); + +void alBufferCallback1(int buffer /* key */, int format, int freq, ALBUFFERCALLBACKTYPESOFT callback, void *userptr); +// void alBufferCallback1Inject(int buffer, void *sampledata, int numbytes); +void alBufferCallback1Inject(int buffer, int sampledata, int numbytes); + +// +// T2_CallbackFunc11 // typedef struct { int32_t ApiVersion; void* Data; -} T2_Callback02UserType; +} T2_Callback11UserType; -typedef void ( * T2_CallbackFunc02)(const T2_Callback02UserType* usrParam); +typedef void ( * T2_CallbackFunc11)(const T2_Callback11UserType* usrParam); -void MessageCallback02(T2_CallbackFunc02 cbFunc, const T2_Callback02UserType* usrParam); -void InjectMessageCallback02(size_t id, const char* msg); +void MessageCallback11(T2_CallbackFunc11 cbFunc, const T2_Callback11UserType* usrParam); +void InjectMessageCallback11(size_t id, const char* msg); |