Example #1
0
 private Object rowCountResult(int rowCount) {
   final Object result;
   if (method.returnsVoid()) {
     result = null;
   } else if (Integer.class.equals(method.getReturnType())
       || Integer.TYPE.equals(method.getReturnType())) {
     result = Integer.valueOf(rowCount);
   } else if (Long.class.equals(method.getReturnType())
       || Long.TYPE.equals(method.getReturnType())) {
     result = Long.valueOf(rowCount);
   } else if (Boolean.class.equals(method.getReturnType())
       || Boolean.TYPE.equals(method.getReturnType())) {
     result = Boolean.valueOf(rowCount > 0);
   } else {
     throw new BindingException(
         "Mapper method '"
             + command.getName()
             + "' has an unsupported return type: "
             + method.getReturnType());
   }
   return result;
 }
Example #2
0
    private static void linkGlobalProperty(Class clz, Map<String, String> propertiesMap) {
        for (Field f : clz.getDeclaredFields()) {
            GlobalProperty at = f.getAnnotation(GlobalProperty.class);
            if (at == null) {
                continue;
            }

            if (!Modifier.isStatic(f.getModifiers())) {
                throw new CloudRuntimeException(String.format("%s.%s is annotated by @GlobalProperty but it's not defined with static modifier", clz.getName(), f.getName()));
            }

            Object valueToSet = null;
            String name = at.name();
            if (Map.class.isAssignableFrom(f.getType())) {
                Map ret = linkGlobalPropertyMap(name);
                if (ret.isEmpty() && at.required()) {
                    throw new IllegalArgumentException(String.format("A required global property[%s] missing in zstack.properties", name));
                }
                valueToSet = ret;
            }  else if (List.class.isAssignableFrom(f.getType())) {
                List ret = linkGlobalPropertyList(name);
                if (ret.isEmpty() && at.required()) {
                    throw new IllegalArgumentException(String.format("A required global property[%s] missing in zstack.properties", name));
                }
                valueToSet = ret;
            } else {
                String value = getGlobalProperty(name);
                if (value == null && at.defaultValue().equals(GlobalProperty.DEFAULT_NULL_STRING) && at.required()) {
                    throw new IllegalArgumentException(String.format("A required global property[%s] missing in zstack.properties", name));
                }

                if (value == null) {
                    value = at.defaultValue();
                }

                if (GlobalProperty.DEFAULT_NULL_STRING.equals(value)) {
                    value = null;
                }

                if (value != null) {
                    value = StringTemplate.subsititute(value, propertiesMap);
                }

                if (Integer.class.isAssignableFrom(f.getType()) || Integer.TYPE.isAssignableFrom(f.getType())) {
                    valueToSet =  TypeUtils.stringToValue(value, Integer.class, 0);
                } else if (Long.class.isAssignableFrom(f.getType()) || Long.TYPE.isAssignableFrom(f.getType())) {
                    valueToSet =  TypeUtils.stringToValue(value, Long.class, 0L);
                } else if (Float.class.isAssignableFrom(f.getType()) || Float.TYPE.isAssignableFrom(f.getType())) {
                    valueToSet = TypeUtils.stringToValue(value, Float.class, 0F);
                } else if (Double.class.isAssignableFrom(f.getType()) || Double.TYPE.isAssignableFrom(f.getType())) {
                    valueToSet = TypeUtils.stringToValue(value, Double.class, 0D);
                } else if (String.class.isAssignableFrom(f.getType())) {
                    valueToSet = value;
                } else if (Boolean.class.isAssignableFrom(f.getType()) || Boolean.TYPE.isAssignableFrom(f.getType())) {
                    valueToSet = TypeUtils.stringToValue(value, Boolean.class);
                } else {
                    throw new CloudRuntimeException(String.format("%s.%s of type[%s] is unsupported by global property. try use Platform.getGlobalProperty() and parse by yourself",
                            clz.getName(), f.getName(), f.getType().getName()));
                }
            }

            f.setAccessible(true);
            try {
                f.set(null, valueToSet);
                globalProperties.put(name, valueToSet == null ? "null" : valueToSet.toString());
                logger.debug(String.format("linked global property[%s.%s], value: %s", clz.getName(), f.getName(), valueToSet));
            } catch (IllegalAccessException e) {
                throw new CloudRuntimeException(String.format("unable to link global property[%s.%s]", clz.getName(), f.getName()), e);
            }
        }
    }
 private boolean compare_PrimitiveArray(
     int operation, Class type, Object primarray, Object value2) {
   if (Integer.TYPE.isAssignableFrom(type)) {
     int[] array = (int[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Integer(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Long.TYPE.isAssignableFrom(type)) {
     long[] array = (long[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Long(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Byte.TYPE.isAssignableFrom(type)) {
     byte[] array = (byte[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Byte(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Short.TYPE.isAssignableFrom(type)) {
     short[] array = (short[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Short(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Character.TYPE.isAssignableFrom(type)) {
     char[] array = (char[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Character(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Float.TYPE.isAssignableFrom(type)) {
     float[] array = (float[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Float(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Double.TYPE.isAssignableFrom(type)) {
     double[] array = (double[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Double(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   if (Boolean.TYPE.isAssignableFrom(type)) {
     boolean[] array = (boolean[]) primarray;
     for (int i = 0, size = array.length; i < size; i++) {
       if (compare_Boolean(operation, array[i], value2)) {
         return true;
       }
     }
     return false;
   }
   return false;
 }
Example #4
0
 private static Map<String, Class<?>> createCommonJavaClassesMap() {
   Map<String, Class<?>> m = new HashMap<>();
   m.put("java.lang.String", java.lang.String.class);
   m.put("String", java.lang.String.class);
   m.put("java.lang.CharSequence", java.lang.CharSequence.class);
   m.put("CharSequence", java.lang.CharSequence.class);
   m.put("java.sql.Timestamp", java.sql.Timestamp.class);
   m.put("Timestamp", java.sql.Timestamp.class);
   m.put("java.sql.Time", java.sql.Time.class);
   m.put("Time", java.sql.Time.class);
   m.put("java.sql.Date", java.sql.Date.class);
   m.put("Date", java.sql.Date.class);
   m.put("java.util.Locale", java.util.Locale.class);
   m.put("java.util.TimeZone", java.util.TimeZone.class);
   m.put("java.lang.Byte", java.lang.Byte.class);
   m.put("java.lang.Character", java.lang.Character.class);
   m.put("java.lang.Integer", java.lang.Integer.class);
   m.put("Integer", java.lang.Integer.class);
   m.put("java.lang.Long", java.lang.Long.class);
   m.put("Long", java.lang.Long.class);
   m.put("java.lang.Short", java.lang.Short.class);
   m.put("java.lang.Float", java.lang.Float.class);
   m.put("Float", java.lang.Float.class);
   m.put("java.lang.Double", java.lang.Double.class);
   m.put("Double", java.lang.Double.class);
   m.put("java.math.BigDecimal", java.math.BigDecimal.class);
   m.put("BigDecimal", java.math.BigDecimal.class);
   m.put("java.math.BigInteger", java.math.BigInteger.class);
   m.put("BigInteger", java.math.BigInteger.class);
   m.put("java.lang.Boolean", java.lang.Boolean.class);
   m.put("Boolean", java.lang.Boolean.class);
   m.put("java.lang.Object", java.lang.Object.class);
   m.put("Object", java.lang.Object.class);
   m.put("java.sql.Blob", java.sql.Blob.class);
   m.put("Blob", java.sql.Blob.class);
   m.put("java.nio.ByteBuffer", java.nio.ByteBuffer.class);
   m.put("java.sql.Clob", java.sql.Clob.class);
   m.put("Clob", java.sql.Clob.class);
   m.put("java.util.Date", java.util.Date.class);
   m.put("java.util.Collection", java.util.Collection.class);
   m.put("Collection", java.util.Collection.class);
   m.put("java.util.List", java.util.List.class);
   m.put("List", java.util.List.class);
   m.put("java.util.ArrayList", java.util.ArrayList.class);
   m.put("ArrayList", java.util.ArrayList.class);
   m.put("java.util.Map", java.util.Map.class);
   m.put("Map", java.util.Map.class);
   m.put("java.util.HashMap", java.util.HashMap.class);
   m.put("java.util.Set", java.util.Set.class);
   m.put("Set", java.util.Set.class);
   m.put("java.util.HashSet", java.util.HashSet.class);
   m.put("groovy.util.Node", groovy.util.Node.class);
   m.put("Node", groovy.util.Node.class);
   m.put("org.moqui.util.MNode", org.moqui.util.MNode.class);
   m.put("MNode", org.moqui.util.MNode.class);
   m.put(Boolean.TYPE.getName(), Boolean.TYPE);
   m.put(Short.TYPE.getName(), Short.TYPE);
   m.put(Integer.TYPE.getName(), Integer.TYPE);
   m.put(Long.TYPE.getName(), Long.TYPE);
   m.put(Float.TYPE.getName(), Float.TYPE);
   m.put(Double.TYPE.getName(), Double.TYPE);
   m.put(Byte.TYPE.getName(), Byte.TYPE);
   m.put(Character.TYPE.getName(), Character.TYPE);
   m.put("long[]", long[].class);
   m.put("char[]", char[].class);
   return m;
 }