public void testStructureOptionsInference() { Structure s = new OptionsBase.TypeMappedStructure(); assertEquals( "Wrong structure alignment for base structure", Structure.ALIGN_NONE, Native.getStructureAlignment(s.getClass())); assertEquals( "Wrong type mapper for base structure", OptionsBase.TYPE_MAPPER, s.getTypeMapper()); }
/** Tests a structure (segment or group) against the corresponding part of a profile. */ protected List<ValidationException> testStructure(Structure s, Object profile) { List<ValidationException> exList = new ArrayList<>(); if (profile instanceof SegmentType) { if (Segment.class.isAssignableFrom(s.getClass())) { exList.addAll(testSegment((Segment) s, (SegmentType) profile)); } else { profileNotHL7Compliant( exList, PROFILE_STRUCTURE_MISMATCH, "segment", s.getClass().getName()); } } else if (profile instanceof HL7V2XStaticDef.SegGroup) { if (Group.class.isAssignableFrom(s.getClass())) { exList.addAll( testGroup((Group) s, ((HL7V2XStaticDef.SegGroup) profile).getSegGroupsAndSegments())); } else { profileNotHL7Compliant(exList, PROFILE_STRUCTURE_MISMATCH, "group", s.getClass().getName()); } } return exList; }
private Object convertArgument( Object[] args, int index, Method invokingMethod, TypeMapper mapper, boolean allowObjects, Class expectedType) { Object arg = args[index]; if (arg != null) { Class type = arg.getClass(); ToNativeConverter converter = null; if (NativeMapped.class.isAssignableFrom(type)) { converter = NativeMappedConverter.getInstance(type); } else if (mapper != null) { converter = mapper.getToNativeConverter(type); } if (converter != null) { ToNativeContext context; if (invokingMethod != null) { context = new MethodParameterContext(this, args, index, invokingMethod); } else { context = new FunctionParameterContext(this, args, index); } arg = converter.toNative(arg, context); } } if (arg == null || isPrimitiveArray(arg.getClass())) { return arg; } Class argClass = arg.getClass(); // Convert Structures to native pointers if (arg instanceof Structure) { Structure struct = (Structure) arg; struct.autoWrite(); if (struct instanceof Structure.ByValue) { // Double-check against the method signature, if available Class ptype = struct.getClass(); if (invokingMethod != null) { Class[] ptypes = invokingMethod.getParameterTypes(); if (isVarArgs(invokingMethod)) { if (index < ptypes.length - 1) { ptype = ptypes[index]; } else { Class etype = ptypes[ptypes.length - 1].getComponentType(); if (etype != Object.class) { ptype = etype; } } } else { ptype = ptypes[index]; } } if (Structure.ByValue.class.isAssignableFrom(ptype)) { return struct; } } return struct.getPointer(); } // Convert Callback to Pointer else if (arg instanceof Callback) { return CallbackReference.getFunctionPointer((Callback) arg); } // String arguments are converted to native pointers here rather // than in native code so that the values will be valid until // this method returns. // Convert String to native pointer (const) else if (arg instanceof String) { return new NativeString((String) arg, false).getPointer(); } // Convert WString to native pointer (const) else if (arg instanceof WString) { return new NativeString(arg.toString(), true).getPointer(); } // Default conversion of boolean to int; if you want something // different, use a ToNativeConverter else if (arg instanceof Boolean) { return Boolean.TRUE.equals(arg) ? INTEGER_TRUE : INTEGER_FALSE; } else if (String[].class == argClass) { return new StringArray((String[]) arg, encoding); } else if (WString[].class == argClass) { return new StringArray((WString[]) arg); } else if (Pointer[].class == argClass) { return new PointerArray((Pointer[]) arg); } else if (NativeMapped[].class.isAssignableFrom(argClass)) { return new NativeMappedArray((NativeMapped[]) arg); } else if (Structure[].class.isAssignableFrom(argClass)) { // If the signature is Structure[], disallow // Structure.ByReference[] and Structure.ByReference elements Structure[] ss = (Structure[]) arg; Class type = argClass.getComponentType(); boolean byRef = Structure.ByReference.class.isAssignableFrom(type); if (expectedType != null) { if (!Structure.ByReference[].class.isAssignableFrom(expectedType)) { if (byRef) { throw new IllegalArgumentException( "Function " + getName() + " declared Structure[] at parameter " + index + " but array of " + type + " was passed"); } for (int i = 0; i < ss.length; i++) { if (ss[i] instanceof Structure.ByReference) { throw new IllegalArgumentException( "Function " + getName() + " declared Structure[] at parameter " + index + " but element " + i + " is of Structure.ByReference type"); } } } } if (byRef) { Structure.autoWrite(ss); Pointer[] pointers = new Pointer[ss.length + 1]; for (int i = 0; i < ss.length; i++) { pointers[i] = ss[i] != null ? ss[i].getPointer() : null; } return new PointerArray(pointers); } else if (ss.length == 0) { throw new IllegalArgumentException("Structure array must have non-zero length"); } else if (ss[0] == null) { Structure.newInstance(type).toArray(ss); return ss[0].getPointer(); } else { Structure.autoWrite(ss); return ss[0].getPointer(); } } else if (argClass.isArray()) { throw new IllegalArgumentException( "Unsupported array argument type: " + argClass.getComponentType()); } else if (allowObjects) { return arg; } else if (!Native.isSupportedNativeType(arg.getClass())) { throw new IllegalArgumentException( "Unsupported argument type " + arg.getClass().getName() + " at parameter " + index + " of function " + getName()); } return arg; }