예제 #1
0
  /**
   * We are allowing consumers of the SDK to register their own deriived classes from the base
   * models we have inside the SDK. This allows for cases where the consumer wants to add addtional
   * flags and functions to the model and yet have orginal parsed objects of his liking. Example
   * SFFile does not provide the isSynced flag. The consumer app can extend like :
   *
   * <p>SFFileEx extends SFFile <br>
   * { <br>
   * boolean mIsSync <br>
   * }
   *
   * @throws IllegalAccessException
   * @throws InstantiationException
   * @throws SFInvalidTypeException
   */
  public static void registerSubClass(SFV3ElementType elementType, Class<?> newClass)
      throws InstantiationException, IllegalAccessException, SFInvalidTypeException {
    if (newClass == null) {
      throw new SFInvalidTypeException(
          " NULL does not extend " + elementType.mOriginalClass.toString());
    }

    // test if the new class is a real extension of the type being replaced.
    if (!elementType.mOriginalClass.isInstance(newClass.newInstance())) {
      String msg =
          newClass.toString() + " does not extend " + elementType.mOriginalClass.toString();

      Logger.d(TAG, msg);

      throw new SFInvalidTypeException(msg);
    }

    Logger.d(
        TAG,
        "Successfully registered : "
            + newClass.toString()
            + " to replace "
            + elementType.mOriginalClass.toString());

    elementType.mOverrideClass = newClass;

    registerSubClass(elementType.mToString.replace(prefix, "").replace(suffix, ""), newClass);
  }
예제 #2
0
 /**
  * オブジェクトのフィールドにデータを設定する<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);
   }
 }
예제 #3
0
  /**
   * Returns the {@link ComponentUI} for the specified {@link JComponent}.
   *
   * @param target the component for which the ComponentUI is requested
   * @return the {@link ComponentUI} for the specified {@link JComponent}
   */
  public ComponentUI getUI(JComponent target) {
    String classId = target.getUIClassID();
    Class cls = getUIClass(classId);
    if (cls == null) {
      getUIError("failed to locate UI class:" + classId);
      return null;
    }

    Method factory;

    try {
      factory = cls.getMethod("createUI", new Class[] {JComponent.class});
    } catch (NoSuchMethodException nme) {
      getUIError("failed to locate createUI method on " + cls.toString());
      return null;
    }

    try {
      return (ComponentUI) factory.invoke(null, new Object[] {target});
    } catch (java.lang.reflect.InvocationTargetException ite) {
      getUIError(
          "InvocationTargetException ("
              + ite.getTargetException()
              + ") calling createUI(...) on "
              + cls.toString());
      return null;
    } catch (Exception e) {
      getUIError("exception calling createUI(...) on " + cls.toString());
      return null;
    }
  }
예제 #4
0
  public static void registerSubClass(String originalClassName, Class<?> newClass)
      throws InstantiationException, IllegalAccessException, SFInvalidTypeException {
    if (newClass == null || originalClassName == null) {
      throw new SFInvalidTypeException(" NULL classes not allowed ");
    }

    Class originalClass = SFEntityTypeMap.getEntityTypeMap().get(originalClassName);

    if (originalClass == null) {
      throw new SFInvalidTypeException("Given Class does not exist");
    }

    // test if the new class is a real extension of the type being replaced.
    if (!originalClass.isInstance(newClass.newInstance())) {
      String msg = newClass.toString() + " does not extend " + originalClass.toString();

      Logger.d(TAG, msg);

      throw new SFInvalidTypeException(msg);
    }

    SFEntityTypeMap.getEntityTypeMap().put(originalClassName, newClass);
    SFDefaultGsonParser.routeSpecialClasses(originalClassName, newClass);

    Logger.d(
        TAG,
        "Successfully registered : "
            + newClass.toString()
            + " to replace "
            + originalClass.toString());
  }
예제 #5
0
 /**
  * Returns the RDFS Class URI for a model POJO class. The POJO class must contain a field named
  * 'RDFS_CLASS', and its value should be the class URI.
  *
  * @param clazz the Java class to extract the URI
  * @return the RDFS Class URI
  */
 public static <T extends Resource> URI getUriOfClass(Class<T> clazz) {
   URI typeUri = null;
   try {
     typeUri = (URI) clazz.getDeclaredField("RDFS_CLASS").get("");
     logger.debug("RDFS_CLASS is " + typeUri + " for class " + clazz.toString());
   } catch (Exception e) {
     logger.error("RDFS_CLASS attribute is not defined for the class " + clazz.toString());
   }
   return typeUri;
 }
예제 #6
0
 /**
  * Get a {@link java.lang.reflect.Constructor Constructor} from a {@link java.lang.Class Class}
  * that you normally can't use.
  *
  * @param temp The {@link java.lang.Class Class} that you want to get the {@link
  *     java.lang.reflect.Constructor Constructor} form.
  * @param parameters The parameters of the {@link java.lang.reflect.Constructor Constructor} that
  *     you want to get.
  * @return The {@link java.lang.reflect.Constructor Constructor} that you requested and makes them
  *     accessible.
  */
 public static Constructor getConstructor(Class<?> temp, Class... parameters) {
   try {
     Constructor constructor = temp.getDeclaredConstructor(parameters);
     return constructor;
   } catch (NoSuchMethodException e) {
     Log.error("There is no constructor for the class : " + temp.toString() + " :");
     return null;
   } catch (SecurityException e) {
     Log.error("you can not access the constructor of this class : " + temp.toString() + " :");
     return null;
   }
 }
예제 #7
0
파일: K9.java 프로젝트: kamilk/k-9
 public static Method getMethod(Class<?> classObject, String methodName) {
   try {
     return classObject.getMethod(methodName, boolean.class);
   } catch (NoSuchMethodException e) {
     Log.i(K9.LOG_TAG, "Can't get method " + classObject.toString() + "." + methodName);
   } catch (Exception e) {
     Log.e(
         K9.LOG_TAG,
         "Error while using reflection to get method " + classObject.toString() + "." + methodName,
         e);
   }
   return null;
 }
예제 #8
0
  public static void main(String args[]) {

    Elephant Nellie = new Elephant("Nellie");

    LinkedList<String> nellieLikes = new LinkedList<String>();

    // Try adding more than apples?
    nellieLikes.add("apples");
    // nellieLikes.add( "elephants" );

    Nellie.setLikes(nellieLikes);

    // What happens to the 'likes' print out if nellie likes more than one thing?
    System.out.println(Nellie.getName() + " likes " + Nellie.getLikes().getFirst());
    System.out.println(
        Nellie.getName() + " is an instance of " + Nellie.getClass().getSuperclass());

    // This just iterates through the superclasses of Nellie, working up the inheritance tree.
    Class cls = Nellie.getClass();
    Class oldCls = cls;
    while ((cls = cls.getSuperclass()) != null) {

      if (cls.toString().equals("class java.lang.Object")) {
        System.out.println("And in Java, every Object is an instance of " + cls);
      } else {
        System.out.println(oldCls + " is an instance of: " + cls);
      }

      oldCls = cls;
    }
  }
예제 #9
0
  private void setUsage(Class<?> optionHolderClass) {
    Usage newUsage = optionHolderClass.getAnnotation(Usage.class);
    if (newUsage == null)
      throw new XerialError(XerialErrorCode.NO_USAGE_ANNOTATION, optionHolderClass.toString());

    if (usage == null) usage = newUsage;
  }
  @Override
  protected void onResume() {
    super.onResume();

    registerReceiver(receiver, new IntentFilter(service.toString()));
    updateItems();
  }
예제 #11
0
  public Object getAdapter(Class adapter) {
    AdapterDebug.print(this, adapter);

    if (adapter.equals(ILaunch.class)) {
      return target.getAdapter(adapter);

    } else if (adapter.equals(org.eclipse.debug.ui.actions.IRunToLineTarget.class)) {
      return this.target.getRunToLineTarget();

    } else if (adapter.equals(IPropertySource.class)
        || adapter.equals(ITaskListResourceAdapter.class)
        || adapter.equals(org.eclipse.ui.IContributorResourceAdapter.class)
        || adapter.equals(org.eclipse.ui.IActionFilter.class)
        || adapter.equals(org.eclipse.ui.model.IWorkbenchAdapter.class)
        || adapter.equals(org.eclipse.debug.ui.actions.IToggleBreakpointsTarget.class)
        || adapter.equals(IResource.class)
        || adapter.equals(org.eclipse.core.resources.IFile.class)) return super.getAdapter(adapter);
    // ongoing, I do not fully understand all the interfaces they'd like me to support
    // so I print them out as errors
    if (adapter.equals(IDeferredWorkbenchAdapter.class)) {
      return new DeferredWorkbenchAdapter(this);
    }

    // cannot check for the actual interface because it may not be available on eclipse 3.2 (it's
    // only available
    // from 3.3 onwards... and this is only a hack for it to work with eclipse 3.4)
    if (adapter
        .toString()
        .endsWith(
            "org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider")) {
      return new PyVariableContentProviderHack();
    }
    AdapterDebug.printDontKnow(this, adapter);
    return super.getAdapter(adapter);
  }
예제 #12
0
  public void toScreen(String s, Class module, String TYPE) {
    Color c = Color.BLACK;
    if (TYPE != null) {
      if (TYPE.contains("ERROR")) c = Color.RED;
      if (TYPE.contains("WARNING")) c = new Color(255, 106, 0);
      if (TYPE.contains("DEBUG")) c = Color.BLUE;
      if (module.toString().equalsIgnoreCase("Exception")) c = Color.RED;
    }
    StyleContext sc = StyleContext.getDefaultStyleContext();
    javax.swing.text.AttributeSet aset =
        sc.addAttribute(SimpleAttributeSet.EMPTY, StyleConstants.Foreground, c);
    int len = SCREEN.getDocument().getLength(); // same value as
    SCREEN.setCaretPosition(len); // place caret at the end (with no selection)
    SCREEN.setCharacterAttributes(aset, false);
    SCREEN.replaceSelection(
        "["
            + getData()
            + " - "
            + module.getSimpleName()
            + " - "
            + TYPE
            + "] "
            + s
            + "\n"); // there is no selection, so inserts at caret
    SCREEN.setFont(new Font("Monospaced", Font.PLAIN, 14));

    aggiungiRiga(s, module, TYPE);
  }
  /**
   * Erzeugt eine neue HerkuftsVariante (RassenVariante, KulturVariante oder ProfessionsVarianet).
   * VORSICHT: In dieser Methode wird (noch) NICHT die Variante beim Parent gesetzt.
   *
   * @param clazz Die Klasse der gewünschten zu erzeugenden Variante
   * @param parent Die Herkunft, von der die Variante abstammt
   * @return Eine neue Variante von "parent" vom typ "clazz"
   */
  public CharElement buildHerkunftVariante(Class clazz, Herkunft parent) {
    CharElement charElem;

    // TODO Auch im parent muß die variante natürlich gesetzt werden -
    // entweder hier ober je nach GUI auch im Editor
    if (clazz == RasseVariante.class || clazz == Rasse.class) {
      charElem = new RasseVariante();
      ((RasseVariante) charElem).setVarianteVon((Rasse) parent);
      ((RasseVariante) charElem).setAdditionsVariante(true);
      ((RasseVariante) charElem).setGeschwindigk(((Rasse) parent).getGeschwindigk());

    } else if (clazz == KulturVariante.class || clazz == Kultur.class) {
      charElem = new KulturVariante();
      ((KulturVariante) charElem).setVarianteVon((Kultur) parent);
      ((KulturVariante) charElem).setAdditionsVariante(true);

    } else if (clazz == ProfessionVariante.class || clazz == Profession.class) {
      charElem = new ProfessionVariante();
      ((ProfessionVariante) charElem).setVarianteVon((Profession) parent);
      ((ProfessionVariante) charElem).setAdditionsVariante(true);
      ((ProfessionVariante) charElem).setAufwand(((Profession) parent).getAufwand());

    } else {
      throw new IllegalArgumentException(
          "Keine Behandlung für ein Element des Typs " + clazz.toString() + " vorhanden.");
    }

    createCharElement(charElem);

    return charElem;
  }
  public FunctionContainer() {
    functions = new HashMap<String, Method>();
    numFunctions = 0;

    try {
      String fullClassName = this.getClass().getName();
      Class<?> myClassName = Class.forName(fullClassName);

      Method[] methods = myClassName.getMethods();

      if (methods.length > 0) {
        for (int i = 0; i < methods.length; i++) {
          Method m = methods[i];

          if (m.getName().contains("function")) {
            Class<?>[] paramTypes = m.getParameterTypes();
            if (paramTypes.length > 0) {
              Class<?> lastParamType = paramTypes[paramTypes.length - 1];
              if (lastParamType.toString().equals("boolean")) {
                functions.put(m.getName(), m);
              }
            }
          }
        }
        numFunctions = functions.size();
      }
    } catch (Exception e) {
      System.out.println(e);
    }
  }
예제 #15
0
  /** 生成xml */
  public static String generateXML(Object object) {
    Class cls_class = object.getClass();
    String cls_str = cls_class.toString();
    String objname =
        cls_str.substring(cls_str.lastIndexOf(".") + 1, cls_str.length()); // 得到类名称,包含前缀
    StringBuffer xml = new StringBuffer();
    // 重命名

    objname = "ops_trade";
    xml.append("<" + objname + ">");
    Field[] fields = cls_class.getDeclaredFields(); // 得到成员属性名称,不包含前缀
    String name = "";
    try {
      for (int i = 0; i < fields.length; i++) {
        name = fields[i].getName();
        if (name.equals("preTradeLot") || name.equals("preTrade")) { // 如果是序列号就去掉
          continue;
        }
        Object objValue = PropertyUtils.getProperty(object, name); // 得到属性值
        xml.append(getFieldValue(objValue, name));
      }

    } catch (Exception e) {
      log.error("在" + object + "中没有找到属性名为" + name + "的方法...", e);
    }
    xml.append("</" + objname + ">");
    return xml.toString();
  }
예제 #16
0
  public RemoteInterfaceDescriptor getRemoteDescriptor(Class type) {
    TypeDescriptor td = getDescriptor(type);
    RemoteInterfaceDescriptor result = td.getRemoteInterface();

    if (result != null) {
      return result;
    }

    RemoteDescriptor desc;

    if (java.rmi.Remote.class.isAssignableFrom(type)) {
      if (type.isInterface()) {
        desc = new RemoteInterfaceDescriptor(type, this);
      } else {
        desc = new RemoteClassDescriptor(type, this);
      }

      desc.init();
    } else {
      throw new IllegalArgumentException(
          "class " + type.toString() + " does not implement" + " java.rmi.Remote");
    }

    result = desc.getRemoteInterface();
    td.setRemoteInterface(result);

    return result;
  }
예제 #17
0
 @SuppressWarnings("unchecked")
 public SimulationMaster(
     int numberOfEventEmitters,
     Class eventEmitterClass,
     ActorRef listener,
     int numberOfEvents,
     long demoId,
     int messageDelay) {
   logger.info(
       "Starting simulation with "
           + numberOfEventEmitters
           + " of "
           + eventEmitterClass
           + " Event Emitters -- "
           + eventEmitterClass.toString());
   this.listener = listener;
   this.numberOfEventEmitters = numberOfEventEmitters;
   this.eventEmitterClass = eventEmitterClass;
   this.delay_between_trucks = messageDelay;
   this.numberOfEvents = numberOfEvents;
   eventEmitterRouter =
       this.getContext()
           .actorOf(
               Props.create(eventEmitterClass, numberOfEvents, demoId, messageDelay)
                   .withRouter(new RoundRobinRouter(numberOfEventEmitters)),
               "eventEmitterRouter");
 }
 @SuppressWarnings("unchecked")
 public <S extends EJBObject> EntityEJBLocator<? extends S> narrowAsEntity(final Class<S> type) {
   if (type.isAssignableFrom(getViewType())) {
     return (EntityEJBLocator<? extends S>) this;
   }
   throw new ClassCastException(type.toString());
 }
예제 #19
0
  // taken from TCK facesResourceBundleResolverGetTypeTest
  public String getResourceBundleType() {
    FacesContext context = FacesContext.getCurrentInstance();
    ELContext elContext = context.getELContext();
    ELResolver elResolver = elContext.getELResolver();
    Class type = elResolver.getType(elContext, null, "resourceBundle03");

    return type.toString();
  }
예제 #20
0
 /**
  * Create a new instance of a class using a specific constructor or log the exception if the class
  * is not instanceable. This method will rethrow any exception as an unchecked {@link
  * RuntimeException}.
  *
  * @param <T> the type of the instance to create
  * @param cls the class which represents the type of the instance to create.
  * @param constructor the constructor to use.
  * @param args an array of the constructor arguments.
  * @return a new instance of the type given on the argument by using the specified constructor.
  */
 public static <T> T createInstance(Class<T> cls, Constructor constructor, Object... args) {
   try {
     return (T) constructor.newInstance(args);
   } catch (Throwable t) {
     logger.error("Could not create bean instance of class" + cls.toString(), t);
     throw new RuntimeException(t);
   }
 }
예제 #21
0
 /**
  * Create a new instance of a class or log the exception if the class is not instanceable. This
  * method will rethrow any exception as an unchecked {@link RuntimeException}.
  *
  * @param <T>
  * @param cls
  * @return a new instance of the type given in the argument.
  */
 public static <T> T createInstance(Class<T> cls) {
   try {
     return cls.newInstance();
   } catch (Throwable t) {
     logger.error("Could not create bean instance of class " + cls.toString(), t);
     throw new RuntimeException(t);
   }
 }
예제 #22
0
 @Override
 public String toString() {
   if (typeParameters.size() > 0) {
     return clazz + "<...>";
   } else {
     return clazz.toString();
   }
 }
 private <T extends View> T findView(Class<? extends View> clazz, int id)
     throws ViewNotFoundException {
   View view = getActivity().findViewById(id);
   if (view != null && view.getClass().isAssignableFrom(clazz)) {
     return (T) view;
   }
   log.error("Cannot find view of {} with id {}", clazz.toString(), id);
   throw new ViewNotFoundException();
 }
예제 #24
0
  public static <T> Object newInstance(Class<T> c, int n) {

    if (NyARRleLabelFragmentInfo.class.equals(c)) return new NyARRleLabelFragmentInfo[n];
    else if (SquareStack.Item.class.equals(c)) return new SquareStack.Item[n];
    else if (INyARSingleCameraSystemObserver.class.equals(c)) {
      return new INyARSingleCameraSystemObserver[n];
    } else Window.alert("Creating array of size " + n + " of " + c.toString());
    return null;
  }
예제 #25
0
  /**
   * Removes a given configurable class from registered list.
   *
   * @param interfaze the interface type of configurable class.
   * @return returns the removed configigurabke class if it existed, otherwise returns null.
   */
  @SuppressWarnings("unchecked")
  public static <T> T removeConfigClass(Class<T> interfaze) {

    Assertor.notNull(interfaze);
    if (!interfaze.isInterface()) {
      throw new JGentleRuntimeException(interfaze.toString() + " must be a interface.");
    }
    return (T) JGentle.configObjClassList.remove(interfaze);
  }
예제 #26
0
  /**
   * Given a map between a string and an object of unknown type, attempt to retrieve what value is
   * mapped to from the specified string and validate that the actual type matches the specified
   * class.
   *
   * @return Null if the types do not match, or the value
   */
  private static Object validateAndGet(Map<String, Object> m, String s, Class<?> c)
      throws MissingMappingException, UnexpectedTypeException {
    Object o = m.get(s);
    if (o == null) throw new MissingMappingException(s);

    if (!c.isAssignableFrom(o.getClass()))
      throw new UnexpectedTypeException(s, c.toString(), o.getClass().toString());
    else return o;
  }
예제 #27
0
  @Test
  public void testBeforeAddInterceptor() throws Exception {
    final TestClassLoader loader = getTestClassLoader();
    final String javassistClassName = "com.navercorp.pinpoint.profiler.interceptor.bci.TestObject";

    loader.addTransformer(
        javassistClassName,
        new TransformCallback() {

          @Override
          public byte[] doInTransform(
              Instrumentor instrumentContext,
              ClassLoader classLoader,
              String className,
              Class<?> classBeingRedefined,
              ProtectionDomain protectionDomain,
              byte[] classfileBuffer)
              throws InstrumentException {
            try {
              logger.info("modify className:{} cl:{}", className, classLoader);

              InstrumentClass aClass =
                  instrumentContext.getInstrumentClass(
                      classLoader, javassistClassName, classfileBuffer);

              String methodName = "callA";
              aClass
                  .getDeclaredMethod(methodName)
                  .addInterceptor(
                      "com.navercorp.pinpoint.profiler.interceptor.TestBeforeInterceptor");

              return aClass.toBytecode();
            } catch (InstrumentException e) {
              e.printStackTrace();
              throw new RuntimeException(e.getMessage(), e);
            }
          }
        });

    loader.initialize();

    Class<?> testObjectClazz = loader.loadClass(javassistClassName);
    final String methodName = "callA";
    logger.info("class:{}", testObjectClazz.toString());
    final Object testObject = testObjectClazz.newInstance();
    Method callA = testObjectClazz.getMethod(methodName);
    callA.invoke(testObject);
    Interceptor interceptor = getInterceptor(loader, 0);
    assertEqualsIntField(interceptor, "call", 1);
    assertEqualsObjectField(
        interceptor, "className", "com.navercorp.pinpoint.profiler.interceptor.bci.TestObject");
    assertEqualsObjectField(interceptor, "methodName", methodName);
    assertEqualsObjectField(interceptor, "args", null);

    assertEqualsObjectField(interceptor, "target", testObject);
  }
예제 #28
0
 @SuppressWarnings("unchecked")
 public <T> AbstractGrblSerializer<String, T> getSerializer(Class<T> targetClass)
     throws GkTechnicalException {
   for (AbstractGrblSerializer<?, ?> abstractGrblSerializer : lstSerializer) {
     if (abstractGrblSerializer.getTargetClass() == targetClass) {
       return (AbstractGrblSerializer<String, T>) abstractGrblSerializer;
     }
   }
   throw new GkTechnicalException("No serializer found for class " + targetClass.toString());
 }
예제 #29
0
  public static <T extends Exception> T findExceptionByClass(Exception e, Class<T> exceptionClass) {
    Exception exception = e;
    while (exception != null) {
      if (exception.getClass().toString().equals(exceptionClass.toString()))
        return exceptionClass.cast(exception);
      exception = (Exception) exception.getCause();
    }

    return null;
  }
 @Test
 public void testClass() {
   Class sampleclass = MainSampleListFragment.class;
   Class superclass = sampleclass.getSuperclass();
   System.out.println(superclass.toString());
   System.out.println(superclass.getSuperclass().toString());
   if (superclass == Fragment.class) {
     assert true;
   }
 }