/**
  * オブジェクトのフィールドにデータを設定する<br>
  * Integer、Float、Float[]、Stringにしか対応していない
  *
  * @param obj 設定対象オブジェクト
  * @param fl 設定対象フィールド
  * @param ty 設定対象フィールドの型
  * @param data 設定データ
  * @throws IllegalArgumentException
  * @throws IllegalAccessException
  */
 protected void dataSetter(Object obj, Field fl, Class ty, String data)
     throws IllegalArgumentException, IllegalAccessException {
   // Integer型のデータを設定
   if (ty.toString().equals("class java.lang.Integer")) {
     fl.set(obj, Integer.parseInt(data));
   }
   // Float型のデータを設定
   if (ty.toString().equals("class java.lang.Float")) {
     fl.set(obj, Float.parseFloat(data));
   }
   // String型のデータを設定(""の内側)
   if (ty.toString().equals("class java.lang.String")) {
     fl.set(obj, getDoubleQuoatString(data));
   }
   // Float[]型のデータを設定
   if (ty.toString().equals("class [Ljava.lang.Float;")) {
     String[] s;
     s = data.split(" ");
     Float[] f = new Float[s.length];
     for (int i = 0; i < s.length; i++) {
       f[i] = Float.parseFloat(s[i]);
     }
     fl.set(obj, f);
   }
 }
  /**
   * Calls the callback with every parameter of the method, skipping out the offset parameter
   * introduced by F2J for array arguments.
   *
   * @param method
   * @param callback
   */
  protected void iterateRelevantParameters(
      Method method, boolean offsets, ParameterCallback callback) {
    if (method.getParameterTypes().length == 0) return;

    String[] names = new String[0];
    try {
      names = paranamer.lookupParameterNames(method, true);
    } catch (ParameterNamesNotFoundException e) {
      getLog().warn(e);
    }

    for (int i = 0; i < method.getParameterTypes().length; i++) {
      Class<?> param = method.getParameterTypes()[i];
      if (i > 0
          && !offsets
          && param == Integer.TYPE
          && method.getParameterTypes()[i - 1].isArray()) {
        continue;
      }
      String name;
      if (names.length > 0) name = names[i];
      else name = "arg" + i;

      String offsetName = null;
      if (i < method.getParameterTypes().length - 1
          && param.isArray()
          && method.getParameterTypes()[i + 1] == Integer.TYPE) offsetName = names[i + 1];

      callback.process(i, param, name, offsetName);
    }
  }
Esempio n. 3
0
 /**
  * Defines the specified array of structs as inner structs. The array is populated if necessary
  * using the struct component default constructor (which must be public).
  *
  * @param structs the struct array.
  * @return the specified struct array.
  * @throws IllegalArgumentException if the specified array contains inner structs.
  */
 protected /* <S extends Struct> S*/ Struct[] array(/*S*/ Struct[] structs) {
   Class structClass = null;
   boolean resetIndexSaved = _resetIndex;
   if (_resetIndex) {
     _bitIndex = 0;
     _resetIndex = false; // Ensures the array elements are sequential.
   }
   for (int i = 0; i < structs.length; ) {
     /*S*/ Struct struct = structs[i];
     if (struct == null) {
       try {
         if (structClass == null) {
           String arrayName = structs.getClass().getName();
           String structName = arrayName.substring(2, arrayName.length() - 1);
           structClass = java.lang.Class.forName(structName);
           /*                        if (structClass == null) throw new
           JavolutionError("Struct class: " + structName + " not found");*/
         }
         struct = (/*S*/ Struct) structClass.newInstance();
       } catch (Exception e) {
         System.out.println("Error with struct:" + e);
         return null;
       }
     }
     structs[i++] = inner(struct);
   }
   _resetIndex = resetIndexSaved;
   return (/*S*/ Struct[]) structs;
 }
 public boolean hasOffsets(Method method) {
   Class<?> last = null;
   for (int i = 0; i < method.getParameterTypes().length; i++) {
     Class<?> param = method.getParameterTypes()[i];
     if (last != null && last.isArray() && param.equals(Integer.TYPE)) return true;
     last = param;
   }
   return false;
 }
  /**
   * Returns compact class host.
   *
   * @param obj Object to compact.
   * @return String.
   */
  @Nullable
  public static Object compactObject(Object obj) {
    if (obj == null) return null;

    if (obj instanceof Enum) return obj.toString();

    if (obj instanceof String || obj instanceof Boolean || obj instanceof Number) return obj;

    if (obj instanceof Collection) {
      Collection col = (Collection) obj;

      Object[] res = new Object[col.size()];

      int i = 0;

      for (Object elm : col) res[i++] = compactObject(elm);

      return res;
    }

    if (obj.getClass().isArray()) {
      Class<?> arrType = obj.getClass().getComponentType();

      if (arrType.isPrimitive()) {
        if (obj instanceof boolean[]) return Arrays.toString((boolean[]) obj);
        if (obj instanceof byte[]) return Arrays.toString((byte[]) obj);
        if (obj instanceof short[]) return Arrays.toString((short[]) obj);
        if (obj instanceof int[]) return Arrays.toString((int[]) obj);
        if (obj instanceof long[]) return Arrays.toString((long[]) obj);
        if (obj instanceof float[]) return Arrays.toString((float[]) obj);
        if (obj instanceof double[]) return Arrays.toString((double[]) obj);
      }

      Object[] arr = (Object[]) obj;

      int iMax = arr.length - 1;

      StringBuilder sb = new StringBuilder("[");

      for (int i = 0; i <= iMax; i++) {
        sb.append(compactObject(arr[i]));

        if (i != iMax) sb.append(", ");
      }

      sb.append("]");

      return sb.toString();
    }

    return U.compact(obj.getClass().getName());
  }
Esempio n. 6
0
  int[] init(int... dimensions) {
    int size = dimensions.length > 0 ? dimensions[0] : 0;
    if (___subrecord___ == null) {
      final String[] indexPrefixes = {
        "", "s", "_", "Index", "Length", "Ref", "Header", "Info", "Table"
      };
      for (String indexPrefix : indexPrefixes) {
        try {
          ___subrecord___ =
              (Class<? extends Enum>)
                  Class.forName(getClass().getPackage().getName() + '.' + name() + indexPrefix);
          try {
            size = ___subrecord___.getField("___recordlen___").getInt(null);
          } catch (Exception e) {
          }
          break;
        } catch (ClassNotFoundException e) {
        }
      }
    }

    for (String vPrefixe1 :
        new String[] {
          "_", "", "$", "Value",
        }) {
      if (___valueclass___ != null) break;
      String suffix = vPrefixe1;
      for (String name1 :
          new String[] {
            name().toLowerCase(), name(),
          }) {
        if (___valueclass___ != null) break;
        final String trailName = name1;
        if (trailName.endsWith(suffix)) {
          for (String aPackage1 :
              new String[] {
                "", getClass().getPackage().getName() + ".", "java.lang.", "java.util.",
              })
            if (___valueclass___ == null) break;
            else
              try {
                ___valueclass___ = Class.forName(aPackage1 + name().replace(suffix, ""));
              } catch (ClassNotFoundException e) {
              }
        }
      }
    }

    int seek = dimensions.length > 1 ? dimensions[1] : ___recordlen___;
    ___recordlen___ = Math.max(___recordlen___, seek + size);
    return new int[] {size, seek};
  }
Esempio n. 7
0
 private static void tryCatch(Buffer b, Class<?> ex, Runnable thunk) {
   boolean caught = false;
   try {
     thunk.run();
   } catch (Throwable x) {
     if (ex.isAssignableFrom(x.getClass())) {
       caught = true;
     } else {
       fail(x.getMessage() + " not expected");
     }
   }
   if (!caught) fail(ex.getName() + " not thrown", b);
 }
  protected Class<?> nioBufferClass(Class<?> clazz) {
    Class<?> compType = clazz.getComponentType();

    if (compType == null) {
      return null;
    } else if (compType.equals(Character.TYPE)) {
      return CharBuffer.class;
    } else if (compType.equals(Integer.TYPE)) {
      return IntBuffer.class;
    } else if (compType.equals(Double.TYPE)) {
      return DoubleBuffer.class;
    } else if (compType.equals(Float.TYPE)) {
      return FloatBuffer.class;
    } else if (compType.equals(Long.TYPE)) {
      return LongBuffer.class;
    } else if (compType.equals(Short.TYPE)) {
      return ShortBuffer.class;
      // there's no boolean[]-from-ByteBuffer thing, so we're stuck with
      // boolean[]
      // } else if (compType.equals(Boolean.TYPE)) {
      //    return ByteBuffer.class;
    } else {
      return null;
    }
  }
Esempio n. 9
0
 public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
   Class annotation_class = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
   if (annotation_class.equals(GLint.class)) return "GL11.GL_INT";
   else if (annotation_class.equals(GLbyte.class)) return "GL11.GL_BYTE";
   else if (annotation_class.equals(GLshort.class)) return "GL11.GL_SHORT";
   if (annotation_class.equals(GLuint.class)) return "GL11.GL_UNSIGNED_INT";
   else if (annotation_class.equals(GLubyte.class)) return "GL11.GL_UNSIGNED_BYTE";
   else if (annotation_class.equals(GLushort.class)) return "GL11.GL_UNSIGNED_SHORT";
   else if (annotation_class.equals(GLfloat.class)) return "GL11.GL_FLOAT";
   else if (annotation_class.equals(GLdouble.class)) return "GL11.GL_DOUBLE";
   else return null;
 }
Esempio n. 10
0
 /**
  * Log task mapped.
  *
  * @param log Logger.
  * @param clazz Task class.
  * @param nodes Mapped nodes.
  */
 public static void logMapped(
     @Nullable IgniteLogger log, Class<?> clazz, Collection<ClusterNode> nodes) {
   log0(
       log,
       U.currentTimeMillis(),
       String.format("[%s]: MAPPED: %s", clazz.getSimpleName(), U.toShortString(nodes)));
 }
Esempio n. 11
0
  public static void main(String[] args) throws Exception {
    for (String csname : csnames) {
      System.out.printf("-----------------------------------%n");
      String oldname = csname + "_OLD";
      checkInit(csname);
      Charset csOld = (Charset) Class.forName(oldname).newInstance();
      Charset csNew = Charset.forName(csname);
      char[] cc = checkEncoding(csOld, csNew);
      checkDecoding(csOld, csNew);
      compare(csNew, csOld, cc);

      if (csname.startsWith("x-IBM93")) {
        // ecdbic
        checkMalformed(
            csNew,
            new byte[][] {
              {1, 0x26, 0x0f, 0x27}, // in SBSC, no SI
              {1, 0x0e, 0x41, 0x41, 0xe}, // in DBSC, no SO
              {2, 0x0e, 0x40, 0x41, 0xe}, // illegal DB
            });
      } else if (csname.equals("x-IBM970") || csname.equals("x-IBM1383")) {
        // euc_simple
        checkMalformed(
            csNew,
            new byte[][] {
              {1, 0x26, (byte) 0x8f, 0x27}, // SS2
              {1, (byte) 0xa1, (byte) 0xa1, (byte) 0x8e, 0x51}, // SS3
            });
      }
    }
  }
Esempio n. 12
0
 private static boolean generateParameterJava(
     PrintWriter writer,
     VariableElement param,
     TypeInfo type_info,
     boolean native_stub,
     final boolean printTypes,
     boolean first_parameter,
     Mode mode) {
   Class buffer_type = Utils.getNIOBufferType(param.asType());
   if (!first_parameter) {
     writer.print(", ");
   }
   BufferObject bo_annotation = param.getAnnotation(BufferObject.class);
   if (bo_annotation != null && mode == Mode.BUFFEROBJECT) {
     if (buffer_type == null) {
       throw new RuntimeException(
           "type of "
               + param
               + " is not a nio Buffer parameter but is annotated as buffer object");
     }
     if (printTypes) {
       writer.print("long ");
     }
     writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
   } else {
     if (native_stub && param.getAnnotation(PointerWrapper.class) != null) {
       writer.print("long ");
     } else {
       Class type = type_info.getType();
       if (native_stub
           && (type == CharSequence.class
               || type == CharSequence[].class
               || type == PointerBuffer.class
               || Buffer.class.isAssignableFrom(type))) {
         writer.print("long ");
       } else if (printTypes) {
         writer.print(type.getSimpleName() + " ");
       }
     }
     AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
     if (auto_size_annotation != null) {
       writer.print(auto_size_annotation.value() + "_");
     }
     writer.print(param.getSimpleName());
   }
   return false;
 }
Esempio n. 13
0
 public Class[] getValidAnnotationTypes(Class type) {
   Class[] valid_types;
   if (Buffer.class.isAssignableFrom(type)) valid_types = getValidBufferTypes(type);
   else if (type.isPrimitive()) valid_types = getValidPrimitiveTypes(type);
   else if (String.class.equals(type)) valid_types = new Class[] {GLubyte.class};
   else valid_types = new Class[] {};
   return valid_types;
 }
Esempio n. 14
0
 private static Class[] getValidPrimitiveTypes(Class type) {
   if (type.equals(long.class))
     return new Class[] {
       GLintptrARB.class,
       GLuint.class,
       GLintptr.class,
       GLsizeiptrARB.class,
       GLsizeiptr.class,
       GLint64EXT.class,
       GLuint64EXT.class,
       GLint64.class,
       GLuint64.class
     };
   else if (type.equals(int.class))
     return new Class[] {
       GLbitfield.class, GLenum.class, GLhandleARB.class, GLint.class, GLuint.class, GLsizei.class
     };
   else if (type.equals(double.class)) return new Class[] {GLclampd.class, GLdouble.class};
   else if (type.equals(float.class)) return new Class[] {GLclampf.class, GLfloat.class};
   else if (type.equals(short.class))
     return new Class[] {GLhalf.class, GLshort.class, GLushort.class};
   else if (type.equals(byte.class))
     return new Class[] {GLbyte.class, GLcharARB.class, GLchar.class, GLubyte.class};
   else if (type.equals(boolean.class)) return new Class[] {GLboolean.class};
   else if (type.equals(void.class)) return new Class[] {GLvoid.class, GLreturn.class};
   else return new Class[] {};
 }
Esempio n. 15
0
  /**
   * Log finished.
   *
   * @param log Logger.
   * @param clazz Class.
   * @param start Start time.
   */
  public static void logFinish(@Nullable IgniteLogger log, Class<?> clazz, long start) {
    final long end = U.currentTimeMillis();

    log0(
        log,
        end,
        String.format(
            "[%s]: FINISHED, duration: %s", clazz.getSimpleName(), formatDuration(end - start)));
  }
Esempio n. 16
0
  /**
   * Log message.
   *
   * @param log Logger.
   * @param msg Message to log.
   * @param clazz class.
   * @param start start time.
   * @return Time when message was logged.
   */
  public static long log(@Nullable IgniteLogger log, String msg, Class<?> clazz, long start) {
    final long end = U.currentTimeMillis();

    log0(
        log,
        end,
        String.format(
            "[%s]: %s, duration: %s", clazz.getSimpleName(), msg, formatDuration(end - start)));

    return end;
  }
Esempio n. 17
0
  public static void main(String args[]) {
    Connection c = null;
    PreparedStatement stmt = null;
    try {
      Class.forName("org.postgresql.Driver");
      c = DriverManager.getConnection("jdbc:postgresql://localhost:5432/test", "pdv", "pdv");
      System.out.println("Opened database successfully");
      List<String> results = new ArrayList<String>();
      File dir = new File("D:/jboss/eclipse/workspace/LTF");
      Iterator<File> files =
          FileUtils.iterateFilesAndDirs(dir, TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE);
      StopWatch timerAll = new StopWatch();
      timerAll.start();
      while (files.hasNext()) {
        File file = (File) files.next();
        if (file.isFile()) {
          StopWatch timeForAFile = new StopWatch();
          timeForAFile.start();
          String toDB = encodeFileToBase64Binary(file);
          String sql =
              "INSERT INTO test (file_id,file_name,file_data,file_date) VALUES (nextval('test_file_id_seq'),?,?,?)";
          stmt = c.prepareStatement(sql);

          stmt.setString(1, file.getAbsolutePath());
          stmt.setString(2, toDB);
          stmt.setDate(3, new java.sql.Date(Calendar.getInstance().getTimeInMillis()));
          stmt.executeUpdate();
          timeForAFile.stop();
          System.out.println(timeForAFile.toString());
        }
      }
      timerAll.stop();
      System.out.println("=================================================");
      System.out.println(timerAll.toString());

      stmt.close();
      /*
       * Statement statement = null; statement = c.createStatement();
       * ResultSet rs = statement.executeQuery(
       * "select file_data from test limit 1"); while (rs.next()) { String
       * encoded = rs.getString("file_data"); byte[] decoded =
       * Base64.getDecoder().decode(encoded); FileOutputStream fos = new
       * FileOutputStream("c:/temp/2.jpg"); fos.write(decoded);
       * fos.close(); }
       */

      c.close();
    } catch (Exception e) {
      System.err.println(e.getClass().getName() + ": " + e.getMessage());
      System.exit(0);
    }
    System.out.println("Table created successfully");
  }
Esempio n. 18
0
  /**
   * Tries to load a class from: the bootstrap loader, the system loader, the context loader (if one
   * is present) and finally the loader specified.
   *
   * @param className the name of the class to be loaded
   * @param fallback the fallback loader
   * @return the class loaded
   * @exception ClassNotFoundException if class is not found
   */
  protected static final Class<?> tryToLoadClass(String className, ClassLoader fallback)
      throws ClassNotFoundException {
    ClassLoader systemClassLoader =
        (ClassLoader)
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                  public Object run() {
                    ClassLoader cl = Thread.currentThread().getContextClassLoader();
                    return (cl != null) ? cl : ClassLoader.getSystemClassLoader();
                  }
                });

    try {
      return Class.forName(className, true, systemClassLoader);
    } catch (ClassNotFoundException e2) {
      if (fallback != null) {
        return Class.forName(className, true, fallback);
      } else {
        throw new ClassNotFoundException(className);
      }
    }
  }
Esempio n. 19
0
 private static VariableElement getAutoTypeParameter(
     ExecutableElement method, VariableElement target_parameter) {
   for (VariableElement param : method.getParameters()) {
     AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
     if (auto_annotation != null) {
       Class annotation_type =
           NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
       String parameter_name;
       if (annotation_type.equals(AutoType.class)) {
         parameter_name = param.getAnnotation(AutoType.class).value();
       } else if (annotation_type.equals(AutoSize.class)) {
         parameter_name = param.getAnnotation(AutoSize.class).value();
       } else {
         throw new RuntimeException("Unknown annotation type " + annotation_type);
       }
       if (target_parameter.getSimpleName().toString().equals(parameter_name)) {
         return param;
       }
     }
   }
   return null;
 }
Esempio n. 20
0
 private static Class[] getValidBufferTypes(Class type) {
   if (type.equals(IntBuffer.class)) return new Class[] {cl_int.class, cl_uint.class};
   else if (type.equals(FloatBuffer.class)) return new Class[] {cl_float.class};
   else if (type.equals(ByteBuffer.class))
     return new Class[] {cl_byte.class, cl_char.class, cl_uchar.class, cl_void.class};
   else if (type.equals(ShortBuffer.class)) return new Class[] {cl_short.class};
   else if (type.equals(DoubleBuffer.class)) return new Class[] {cl_double.class};
   else if (type.equals(LongBuffer.class)) return new Class[] {cl_long.class};
   else if (type.equals(PointerBuffer.class)) return new Class[] {size_t.class};
   else return new Class[] {};
 }
Esempio n. 21
0
 @Override
 public Class[] getValidAnnotationTypes(Class type) {
   Class[] valid_types;
   if (Buffer.class.isAssignableFrom(type) || PointerBuffer.class.isAssignableFrom(type))
     valid_types = getValidBufferTypes(type);
   else if (type.isPrimitive()) valid_types = getValidPrimitiveTypes(type);
   else if (String.class.equals(type)) valid_types = new Class[] {cl_byte.class};
   else if (org.lwjgl.PointerWrapper.class.isAssignableFrom(type))
     valid_types = new Class[] {PointerWrapper.class};
   else if (ByteBuffer[].class == type) valid_types = new Class[] {cl_char.class, cl_uchar.class};
   else if (void.class.equals(type)) valid_types = new Class[] {GLreturn.class};
   else valid_types = new Class[] {};
   return valid_types;
 }
Esempio n. 22
0
 public Class[] getValidAnnotationTypes(Class type) {
   Class[] valid_types;
   if (Buffer.class.isAssignableFrom(type)) valid_types = getValidBufferTypes(type);
   else if (type.isPrimitive()) valid_types = getValidPrimitiveTypes(type);
   else if (String.class.equals(type)) valid_types = new Class[] {GLubyte.class};
   else if (org.lwjgl.PointerWrapper.class.isAssignableFrom(type))
     valid_types = new Class[] {PointerWrapper.class};
   else if (void.class.equals(type)) valid_types = new Class[] {GLreturn.class};
   else if (PointerBuffer.class.equals(type))
     valid_types =
         new Class[] {GLintptr.class, GLintptrARB.class, GLsizeiptr.class, GLsizeiptrARB.class};
   else valid_types = new Class[] {};
   return valid_types;
 }
Esempio n. 23
0
 @Override
 public String translateAnnotation(Class annotation_type) {
   if (annotation_type.equals(cl_uint.class) || annotation_type.equals(cl_int.class)) return "i";
   else if (annotation_type.equals(cl_short.class)) return "s";
   else if (annotation_type.equals(cl_byte.class)) return "b";
   else if (annotation_type.equals(cl_float.class)) return "f";
   else if (annotation_type.equals(cl_double.class)) return "d";
   else throw new RuntimeException(annotation_type + " is not allowed");
 }
Esempio n. 24
0
 private static String getDefaultResultValue(ExecutableElement method) {
   if (method.getAnnotation(GLreturn.class) != null) {
     final String type =
         Utils.getMethodReturnType(method, method.getAnnotation(GLreturn.class), false);
     if ("boolean".equals(type)) {
       return "false";
     } else if (Character.isLowerCase(type.charAt(0))) {
       return "0";
     } else {
       return "null";
     }
   } else {
     final Class type = Utils.getJavaType(Utils.getMethodReturnType(method));
     if (type.isPrimitive()) {
       if (type == boolean.class) {
         return "false";
       } else {
         return "0";
       }
     } else {
       return "null";
     }
   }
 }
Esempio n. 25
0
 private static Class[] getValidPrimitiveTypes(Class type) {
   if (type.equals(long.class))
     return new Class[] {cl_long.class, size_t.class, cl_bitfield.class};
   else if (type.equals(int.class))
     return new Class[] {cl_int.class, cl_uint.class, cl_bool.class};
   else if (type.equals(double.class)) return new Class[] {cl_double.class};
   else if (type.equals(float.class)) return new Class[] {cl_float.class};
   else if (type.equals(short.class)) return new Class[] {cl_short.class};
   else if (type.equals(byte.class))
     return new Class[] {cl_byte.class, cl_char.class, cl_uchar.class};
   else if (type.equals(boolean.class)) return new Class[] {cl_bool.class};
   else if (type.equals(void.class)) return new Class[] {cl_void.class};
   else return new Class[] {};
 }
Esempio n. 26
0
 public static String constname(Class<?> cl, int val) {
   String ret = null;
   for (java.lang.reflect.Field f : cl.getFields()) {
     if (((f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
         && ((f.getModifiers() & java.lang.reflect.Modifier.PUBLIC) != 0)
         && (f.getType() == Integer.TYPE)) {
       int v;
       try {
         v = f.getInt(null);
       } catch (IllegalAccessException e) {
         continue;
       }
       if (v == val) {
         if (ret == null) ret = f.getName();
         else ret = ret + " or " + f.getName();
       }
     }
   }
   if (ret == null) return (Integer.toString(val));
   return (ret);
 }
Esempio n. 27
0
 private static Class[] getValidBufferTypes(Class type) {
   if (type.equals(IntBuffer.class))
     return new Class[] {
       GLbitfield.class, GLenum.class, GLhandleARB.class, GLint.class, GLsizei.class, GLuint.class
     };
   else if (type.equals(FloatBuffer.class)) return new Class[] {GLclampf.class, GLfloat.class};
   else if (type.equals(ByteBuffer.class))
     return new Class[] {
       GLboolean.class, GLbyte.class, GLcharARB.class, GLchar.class, GLubyte.class, GLvoid.class
     };
   else if (type.equals(ShortBuffer.class))
     return new Class[] {GLhalf.class, GLshort.class, GLushort.class};
   else if (type.equals(DoubleBuffer.class)) return new Class[] {GLclampd.class, GLdouble.class};
   else if (type.equals(LongBuffer.class))
     return new Class[] {GLint64EXT.class, GLuint64EXT.class};
   else return new Class[] {};
 }
Esempio n. 28
0
  /**
   * Constructs a fully specified <code>DataFlavor</code>.
   *
   * @exception NullPointerException if either <code>primaryType</code>, <code>subType</code> or
   *     <code>representationClass</code> is null
   */
  private DataFlavor(
      String primaryType,
      String subType,
      MimeTypeParameterList params,
      Class representationClass,
      String humanPresentableName) {
    super();
    if (primaryType == null) {
      throw new NullPointerException("primaryType");
    }
    if (subType == null) {
      throw new NullPointerException("subType");
    }
    if (representationClass == null) {
      throw new NullPointerException("representationClass");
    }

    if (params == null) params = new MimeTypeParameterList();

    params.set("class", representationClass.getName());

    if (humanPresentableName == null) {
      humanPresentableName = (String) params.get("humanPresentableName");

      if (humanPresentableName == null) humanPresentableName = primaryType + "/" + subType;
    }

    try {
      mimeType = new MimeType(primaryType, subType, params);
    } catch (MimeTypeParseException mtpe) {
      throw new IllegalArgumentException("MimeType Parse Exception: " + mtpe.getMessage());
    }

    this.representationClass = representationClass;
    this.humanPresentableName = humanPresentableName;

    mimeType.removeParameter("humanPresentableName");
  }
Esempio n. 29
0
  private static void printParameterChecks(
      PrintWriter writer,
      ExecutableElement method,
      Map<VariableElement, TypeInfo> typeinfos,
      Mode mode,
      final boolean generate_error_checks) {
    if (mode == Mode.NORMAL) {
      final GenerateAutos gen_autos_annotation = method.getAnnotation(GenerateAutos.class);
      if (gen_autos_annotation != null && gen_autos_annotation.sizeVariables().length > 0) {
        // For the auto-generated parameters, declare and init a size variable (that can be reused
        // by @Code)
        for (final VariableElement param : method.getParameters()) {
          if (Arrays.binarySearch(
                  gen_autos_annotation.sizeVariables(), param.getSimpleName().toString())
              >= 0) {
            final int shifting = getBufferElementSizeExponent(typeinfos.get(param).getType());
            final Check check_annotation = param.getAnnotation(Check.class);

            writer.print("\t\tlong " + param.getSimpleName() + "_size = ");
            if (check_annotation == null || !check_annotation.canBeNull()) {
              writer.println(param.getSimpleName() + ".remaining() << " + shifting + ";");
            } else {
              writer.println(
                  param.getSimpleName()
                      + " == null ? 0 : "
                      + param.getSimpleName()
                      + ".remaining() << "
                      + shifting
                      + ";");
            }
          }
        }
      }
    }

    for (VariableElement param : method.getParameters()) {
      Class java_type = Utils.getJavaType(param.asType());
      if (java_type.isArray()
          || (Utils.isAddressableType(java_type)
              && (mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null)
              && (mode != Mode.AUTOS || getAutoTypeParameter(method, param) == null)
              && param.getAnnotation(Result.class) == null
              && !Utils.isReturnParameter(method, param))) {
        String check_value = null;
        boolean can_be_null = false;
        Check check_annotation = param.getAnnotation(Check.class);
        if (check_annotation != null) {
          check_value = check_annotation.value();
          can_be_null = check_annotation.canBeNull();
        }
        if ((Buffer.class.isAssignableFrom(java_type)
                || PointerBuffer.class.isAssignableFrom(java_type))
            && param.getAnnotation(Constant.class) == null) {
          TypeInfo typeinfo = typeinfos.get(param);
          printParameterCheck(
              writer,
              method,
              param.getSimpleName().toString(),
              typeinfo.getType().getSimpleName(),
              check_value,
              can_be_null,
              param.getAnnotation(NullTerminated.class),
              generate_error_checks);
        } else if (String.class.equals(java_type)) {
          if (!can_be_null) {
            writer.println("\t\tBufferChecks.checkNotNull(" + param.getSimpleName() + ");");
          }
        } else if (java_type.isArray()) {
          printArrayParameterCheck(
              writer, param.getSimpleName().toString(), check_value, can_be_null);
        }
      }
    }
    if (method.getAnnotation(CachedResult.class) != null) {
      printParameterCheck(
          writer, method, Utils.CACHED_BUFFER_NAME, null, null, true, null, generate_error_checks);
    }
  }
Esempio n. 30
0
 public String translateAnnotation(Class annotation_type) {
   if (annotation_type.equals(GLuint.class) || annotation_type.equals(GLint.class)) return "i";
   else if (annotation_type.equals(GLushort.class) || annotation_type.equals(GLshort.class))
     return "s";
   else if (annotation_type.equals(GLubyte.class) || annotation_type.equals(GLbyte.class))
     return "b";
   else if (annotation_type.equals(GLfloat.class) || annotation_type.equals(GLclampf.class))
     return "f";
   else if (annotation_type.equals(GLdouble.class) || annotation_type.equals(GLclampd.class))
     return "d";
   else if (annotation_type.equals(GLhalf.class)) return "h";
   else if (annotation_type.equals(GLuint64EXT.class)
       || annotation_type.equals(GLint64EXT.class)
       || annotation_type.equals(GLuint64.class)
       || annotation_type.equals(GLint64.class)) return "i64";
   else if (annotation_type.equals(GLboolean.class) || annotation_type.equals(GLvoid.class))
     return "";
   else throw new RuntimeException(annotation_type + " is not allowed");
 }