public void testFindField() throws Exception {
    final Field field = ReflectionUtil.findField(B.class, String.class, "privateA");
    assertNotNull(field);
    assertEquals(String.class, field.getType());
    assertEquals("privateA", field.getName());

    try {
      ReflectionUtil.findField(B.class, String.class, "whatever");
    } catch (NoSuchFieldException e) {
      return;
    }
    fail();
  }
  @NotNull
  public static Icon getIcon(@NonNls @NotNull final String path) {
    Class callerClass = ReflectionUtil.getGrandCallerClass();

    assert callerClass != null : path;
    return getIcon(path, callerClass);
  }
Exemple #3
0
 public static void clearOwnFields(@NotNull Object object) {
   final Field[] all = object.getClass().getDeclaredFields();
   for (Field each : all) {
     if ((each.getModifiers() & (Modifier.FINAL | Modifier.STATIC)) > 0) continue;
     ReflectionUtil.resetField(object, each);
   }
 }
  public void serializeInto(
      @NotNull Object o, @NotNull Element element, @NotNull SerializationFilter filter) {
    for (Binding binding : myPropertyBindings.keySet()) {
      Accessor accessor = myPropertyBindings.get(binding);
      if (!filter.accepts(accessor, o)) {
        continue;
      }

      // todo: optimize. Cache it.
      Property property = accessor.getAnnotation(Property.class);
      if (property != null && property.filter() != SerializationFilter.class) {
        try {
          if (!ReflectionUtil.newInstance(property.filter()).accepts(accessor, o)) {
            continue;
          }
        } catch (RuntimeException e) {
          throw new XmlSerializationException(e);
        }
      }

      Object node = binding.serialize(o, element, filter);
      if (node != null) {
        if (node instanceof org.jdom.Attribute) {
          element.setAttribute((org.jdom.Attribute) node);
        } else {
          JDOMUtil.addContent(element, node);
        }
      }
    }
  }
 @Override
 @Nullable
 public BaseControl createCustomControl(
     final Type type, DomWrapper<String> wrapper, final boolean commitOnEveryChange) {
   final Function<DomWrapper<String>, BaseControl> factory =
       myCustomControlCreators.get(ReflectionUtil.getRawType(type));
   return factory == null ? null : factory.fun(wrapper);
 }
    public AwtPopupWrapper(Popup popup) {
      myPopup = popup;

      if (SystemInfo.isMac && UIUtil.isUnderAquaLookAndFeel()) {
        final Component c =
            (Component) ReflectionUtil.getField(Popup.class, myPopup, Component.class, "component");
        c.setBackground(UIUtil.getPanelBackground());
      }
    }
Exemple #7
0
  public void dispose() {
    try {
      myVirtualMachine.dispose();
    } catch (UnsupportedOperationException e) {
      LOG.info(e);
    }

    // Memory leak workaround, see IDEA-163334
    TargetVM target =
        ReflectionUtil.getField(
            myVirtualMachine.getClass(), myVirtualMachine, TargetVM.class, "target");
    if (target != null) {
      Thread controller =
          ReflectionUtil.getField(target.getClass(), target, Thread.class, "eventController");
      if (controller != null) {
        controller.stop();
      }
    }
  }
 @Nullable
 /**
  * Might return null if icon was not found. Use only if you expected null return value, otherwise
  * see {@link IconLoader#getIcon(java.lang.String)}
  */
 public static Icon findIcon(@NonNls @NotNull String path) {
   Class callerClass = ReflectionUtil.getGrandCallerClass();
   if (callerClass == null) return null;
   return findIcon(path, callerClass);
 }
 public static boolean isTagValueGetter(final JavaMethod method) {
   if (!isGetter(method)) {
     return false;
   }
   if (hasTagValueAnnotation(method)) {
     return true;
   }
   if ("getValue".equals(method.getName())) {
     if (method.getAnnotation(SubTag.class) != null) return false;
     if (method.getAnnotation(SubTagList.class) != null) return false;
     if (method.getAnnotation(Convert.class) != null
         || method.getAnnotation(Resolve.class) != null) {
       return !ReflectionUtil.isAssignable(GenericDomValue.class, method.getReturnType());
     }
     if (ReflectionUtil.isAssignable(DomElement.class, method.getReturnType())) return false;
     return true;
   }
   return false;
 }
 static {
   Class<?> aClass = null;
   Set<String> files = null;
   try {
     aClass = Class.forName("java.io.DeleteOnExitHook");
     files = ReflectionUtil.getField(aClass, null, Set.class, "files");
   } catch (Exception ignored) {
   }
   DELETE_ON_EXIT_HOOK_CLASS = aClass;
   DELETE_ON_EXIT_HOOK_DOT_FILES = files;
 }
 public static void addStringsFromClassToStatics(@NotNull Class aClass) {
   for (Field field : aClass.getDeclaredFields()) {
     if ((field.getModifiers() & Modifier.STATIC) == 0) continue;
     if ((field.getModifiers() & Modifier.PUBLIC) == 0) continue;
     if (!String.class.equals(field.getType())) continue;
     String typeName = ReflectionUtil.getStaticFieldValue(aClass, String.class, field.getName());
     if (typeName != null) {
       staticIntern(typeName);
     }
   }
 }
    public void hide(boolean dispose) {
      myPopup.hide();

      Window wnd = getWindow();
      if (wnd instanceof JWindow) {
        JRootPane rootPane = ((JWindow) wnd).getRootPane();
        if (rootPane != null) {
          ReflectionUtil.resetField(rootPane, "clientProperties");
        }
      }
    }
 @NotNull
 protected <T extends NodeDescriptor> List<T> getSelectedNodes(final Class<T> nodeClass) {
   TreePath[] paths = getSelectionPaths();
   if (paths == null) return Collections.emptyList();
   final ArrayList<T> result = new ArrayList<T>();
   for (TreePath path : paths) {
     Object lastPathComponent = path.getLastPathComponent();
     if (lastPathComponent instanceof DefaultMutableTreeNode) {
       DefaultMutableTreeNode node = (DefaultMutableTreeNode) lastPathComponent;
       Object userObject = node.getUserObject();
       if (userObject != null && ReflectionUtil.isAssignable(nodeClass, userObject.getClass())) {
         result.add((T) userObject);
       }
     }
   }
   return result;
 }
  @Nullable
  private static Icon getAquaMenuInvertedIcon() {
    if (!UIUtil.isUnderAquaLookAndFeel()) return null;
    final Icon arrow = (Icon) UIManager.get("Menu.arrowIcon");
    if (arrow == null) return null;

    try {
      final Method method = ReflectionUtil.getMethod(arrow.getClass(), "getInvertedIcon");
      if (method != null) {
        return (Icon) method.invoke(arrow);
      }
      return null;
    } catch (InvocationTargetException e1) {
      return null;
    } catch (IllegalAccessException e1) {
      return null;
    }
  }
  @Override
  @Nullable
  public PsiElement findElementAt(int offset, @NotNull Class<? extends Language> lang) {
    final PsiFile mainRoot = getPsi(getBaseLanguage());
    PsiElement ret = null;
    for (final Language language : getLanguages()) {
      if (!ReflectionUtil.isAssignable(lang, language.getClass())) continue;
      if (lang.equals(Language.class) && !getLanguages().contains(language)) continue;

      final PsiFile psiRoot = getPsi(language);
      final PsiElement psiElement = findElementAt(psiRoot, offset);
      if (psiElement == null || psiElement instanceof OuterLanguageElement) continue;
      if (ret == null || psiRoot != mainRoot) {
        ret = psiElement;
      }
    }
    return ret;
  }
 @NotNull
 private static ConfigImportSettings getConfigImportSettings() {
   try {
     @SuppressWarnings("unchecked")
     Class<ConfigImportSettings> customProviderClass =
         (Class<ConfigImportSettings>)
             Class.forName(
                 "com.intellij.openapi.application."
                     + PlatformUtils.getPlatformPrefix()
                     + "ConfigImportSettings");
     if (ConfigImportSettings.class.isAssignableFrom(customProviderClass)) {
       return ReflectionUtil.newInstance(customProviderClass);
     }
   } catch (ClassNotFoundException ignored) {
   } catch (RuntimeException ignored) {
   }
   return new ConfigImportSettings();
 }
  public void testResetField() throws Exception {
    final Reset reset = new Reset();

    ReflectionUtil.resetField(reset, String.class, "STRING");
    assertNull(reset.STRING);

    ReflectionUtil.resetField(reset, boolean.class, "BOOLEAN");
    assertFalse(reset.BOOLEAN);

    ReflectionUtil.resetField(reset, int.class, "INT");
    assertEquals(0, reset.INT);

    ReflectionUtil.resetField(reset, double.class, "DOUBLE");
    assertEquals(0d, reset.DOUBLE);

    ReflectionUtil.resetField(reset, float.class, "FLOAT");
    assertEquals(0f, reset.FLOAT);

    ReflectionUtil.resetField(Reset.class, String.class, "STATIC_STRING");
    assertNull(Reset.STATIC_STRING);
  }
  static void initializePlugins(@Nullable StartupProgress progress) {
    configureExtensions();

    final IdeaPluginDescriptorImpl[] pluginDescriptors = loadDescriptors(progress);

    final Class callerClass = ReflectionUtil.findCallerClass(1);
    assert callerClass != null;
    final ClassLoader parentLoader = callerClass.getClassLoader();

    final List<IdeaPluginDescriptorImpl> result = new ArrayList<IdeaPluginDescriptorImpl>();
    final HashMap<String, String> disabledPluginNames = new HashMap<String, String>();
    for (IdeaPluginDescriptorImpl descriptor : pluginDescriptors) {
      if (descriptor.getPluginId().getIdString().equals(CORE_PLUGIN_ID)) {
        final List<String> modules = descriptor.getModules();
        if (modules != null) {
          ourAvailableModules.addAll(modules);
        }
      }

      if (!shouldSkipPlugin(descriptor, pluginDescriptors)) {
        result.add(descriptor);
      } else {
        descriptor.setEnabled(false);
        disabledPluginNames.put(descriptor.getPluginId().getIdString(), descriptor.getName());
        initClassLoader(parentLoader, descriptor);
      }
    }

    prepareLoadingPluginsErrorMessage(filterBadPlugins(result, disabledPluginNames));

    final Map<PluginId, IdeaPluginDescriptorImpl> idToDescriptorMap =
        new HashMap<PluginId, IdeaPluginDescriptorImpl>();
    for (final IdeaPluginDescriptorImpl descriptor : result) {
      idToDescriptorMap.put(descriptor.getPluginId(), descriptor);
    }

    final IdeaPluginDescriptor corePluginDescriptor =
        idToDescriptorMap.get(PluginId.getId(CORE_PLUGIN_ID));
    assert corePluginDescriptor != null
        : CORE_PLUGIN_ID
            + " not found; platform prefix is "
            + System.getProperty(PlatformUtilsCore.PLATFORM_PREFIX_KEY);
    for (IdeaPluginDescriptorImpl descriptor : result) {
      if (descriptor != corePluginDescriptor) {
        descriptor.insertDependency(corePluginDescriptor);
      }
    }

    mergeOptionalConfigs(idToDescriptorMap);

    // sort descriptors according to plugin dependencies
    Collections.sort(result, getPluginDescriptorComparator(idToDescriptorMap));

    for (int i = 0; i < result.size(); i++) {
      ourId2Index.put(result.get(i).getPluginId(), i);
    }

    int i = 0;
    for (final IdeaPluginDescriptorImpl pluginDescriptor : result) {
      if (pluginDescriptor.getPluginId().getIdString().equals(CORE_PLUGIN_ID)
          || pluginDescriptor.isUseCoreClassLoader()) {
        pluginDescriptor.setLoader(parentLoader, true);
      } else {
        final List<File> classPath = pluginDescriptor.getClassPath();
        final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds();
        final ClassLoader[] parentLoaders = getParentLoaders(idToDescriptorMap, dependentPluginIds);

        final ClassLoader pluginClassLoader =
            createPluginClassLoader(
                classPath.toArray(new File[classPath.size()]),
                parentLoaders.length > 0 ? parentLoaders : new ClassLoader[] {parentLoader},
                pluginDescriptor);
        pluginDescriptor.setLoader(pluginClassLoader, true);
      }

      pluginDescriptor.registerExtensions();
      if (progress != null) {
        progress.showProgress(
            "", PLUGINS_PROGRESS_MAX_VALUE + (i++ / (float) result.size()) * 0.35f);
      }
    }

    ourPlugins = pluginDescriptors;
  }
 public Window getWindow() {
   final Component c =
       (Component) ReflectionUtil.getField(Popup.class, myPopup, Component.class, "component");
   return c instanceof JWindow ? (JWindow) c : null;
 }
 @Override
 public T createElement() {
   return ReflectionUtil.newInstance(itemEditor.getItemClass());
 }
 @Nullable
 public static Image loadFromResource(@NonNls @NotNull String s) {
   Class callerClass = ReflectionUtil.getGrandCallerClass();
   if (callerClass == null) return null;
   return loadFromResource(s, callerClass);
 }
 private static void resetPopupTrigger(final MouseEvent e) {
   ReflectionUtil.setField(MouseEvent.class, e, boolean.class, "popupTrigger", false);
 }
 /**
  * This method patches event if it concerns side buttons like 4 (Backward) or 5 (Forward) AND it's
  * not single-click event. We won't support double-click for side buttons. Also some JDK bugs
  * produce zero-click events for side buttons.
  *
  * @return true if event was patched
  */
 public static boolean patchClickCount(final MouseEvent e) {
   if (e.getClickCount() != 1 && e.getButton() > 3) {
     ReflectionUtil.setField(MouseEvent.class, e, int.class, "clickCount", 1);
   }
   return false;
 }
 @Override
 @Nullable
 protected Class create(final Couple<Type> key) {
   return ReflectionUtil.substituteGenericType(key.first, key.second);
 }