com.bugvm.objc.RunnableAsObjCBlockMarshaler Maven / Gradle / Ivy
/*
* Copyright (C) 2014 RoboVM AB
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.bugvm.objc;
import com.bugvm.objc.annotation.Block;
import com.bugvm.rt.bro.Struct;
import com.bugvm.rt.bro.annotation.Bridge;
import com.bugvm.rt.bro.annotation.Callback;
import com.bugvm.rt.bro.annotation.Marshaler;
import com.bugvm.rt.bro.annotation.MarshalsPointer;
import com.bugvm.rt.bro.annotation.Pointer;
/**
* Marshals {@link Runnable} instances. The ObjCBlockPlugin compiler plugin will
* automatically use this as {@link Marshaler} for {@link Block} annotated
* {@link Runnable} types. Also used as template for other auto-generated
* marshaler classes for other {@link Block} annotated types.
*/
public class RunnableAsObjCBlockMarshaler implements Runnable {
private static ObjCBlock.Wrapper WRAPPER =
new ObjCBlock.Wrapper(RunnableAsObjCBlockMarshaler.class);
private ObjCBlock objCBlock;
private RunnableAsObjCBlockMarshaler(ObjCBlock objCBlock) {
this.objCBlock = objCBlock;
}
@MarshalsPointer
public static Runnable toObject(Class cls, long handle, long flags) {
if (handle == 0L) {
return null;
}
ObjCBlock block = Struct.toStruct(ObjCBlock.class, handle);
if (block.hasObject()) {
return (Runnable) block.object();
}
return new RunnableAsObjCBlockMarshaler(block);
}
@MarshalsPointer
public static long toNative(Runnable o, long flags) {
if (o == null) {
return 0L;
}
if (o instanceof RunnableAsObjCBlockMarshaler) {
return ((RunnableAsObjCBlockMarshaler) o).objCBlock.getHandle();
}
// TODO: Retain if returned from callback?
return WRAPPER.toObjCBlock(o).getHandle();
}
// The box()/unbox() methods are used as template methods for auto-generated
// marshalers so they must be here even if this RunnableAsObjCBlockMarshaler
// doesn't need them.
private static Boolean box(boolean v) {
return Boolean.valueOf(v);
}
private static Byte box(byte v) {
return Byte.valueOf(v);
}
private static Short box(short v) {
return Short.valueOf(v);
}
private static Character box(char v) {
return Character.valueOf(v);
}
private static Integer box(int v) {
return Integer.valueOf(v);
}
private static Long box(long v) {
return Long.valueOf(v);
}
private static Float box(float v) {
return Float.valueOf(v);
}
private static Double box(double v) {
return Double.valueOf(v);
}
private static boolean unbox(Boolean v) {
return v.booleanValue();
}
private static byte unbox(Byte v) {
return v.byteValue();
}
private static short unbox(Short v) {
return v.shortValue();
}
private static char unbox(Character v) {
return v.charValue();
}
private static int unbox(Integer v) {
return v.intValue();
}
private static long unbox(Long v) {
return v.longValue();
}
private static float unbox(Float v) {
return v.floatValue();
}
private static double unbox(Double v) {
return v.doubleValue();
}
public void run() {
invoke(objCBlock.invoke(), objCBlock);
}
@Bridge(dynamic = true)
private static native void invoke(@Pointer long target, ObjCBlock block);
@Callback
private static void invoked(ObjCBlock block) {
((Runnable) block.object()).run();
}
}