/**
   * Start at the given nesting level - read lines until you get to line with equal to or greater
   * than the current one.
   */
  public static String[] getArtifactLines(Pointer startingIndex, String... lines) {
    List<String> lineList = new ArrayList<>();
    int index = startingIndex.getIndex();
    String topLine = lines[index];

    lineList.add(
        topLine); // add the line which defines this object - all others, if they exist, are
                  // children.

    int nestingLevel = parseNestingLevel(topLine);

    for (int i = index + 1; i < lines.length; i++) {
      String line = lines[i];

      // we return if the nesting level of the line in question is the same as the "parent" level
      int childNestingLevel = parseNestingLevel(line);

      if (childNestingLevel == nestingLevel) {
        startingIndex.increment(lineList.size());

        // return new array of startIndex to i
        return lineList.toArray(new String[lineList.size()]);
      } else {
        lineList.add(line);
      }
    }

    startingIndex.increment(lineList.size());

    return lineList.toArray(new String[lineList.size()]);
  }
  public static IdeaPluginDescriptorImpl[] loadDescriptors(@Nullable StartupProgress progress) {
    if (ClassUtilCore.isLoadingOfExternalPluginsDisabled()) {
      return IdeaPluginDescriptorImpl.EMPTY_ARRAY;
    }

    final List<IdeaPluginDescriptorImpl> result = new ArrayList<IdeaPluginDescriptorImpl>();

    int pluginsCount =
        countPlugins(PathManager.getPluginsPath())
            + countPlugins(PathManager.getPreinstalledPluginsPath());
    loadDescriptors(PathManager.getPluginsPath(), result, progress, pluginsCount);
    Application application = ApplicationManager.getApplication();
    boolean fromSources = false;
    if (application == null || !application.isUnitTestMode()) {
      int size = result.size();
      loadDescriptors(PathManager.getPreinstalledPluginsPath(), result, progress, pluginsCount);
      fromSources = size == result.size();
    }

    loadDescriptorsFromProperty(result);

    loadDescriptorsFromClassPath(result, fromSources ? progress : null);

    IdeaPluginDescriptorImpl[] pluginDescriptors =
        result.toArray(new IdeaPluginDescriptorImpl[result.size()]);
    try {
      Arrays.sort(pluginDescriptors, new PluginDescriptorComparator(pluginDescriptors));
    } catch (Exception e) {
      prepareLoadingPluginsErrorMessage(
          IdeBundle.message("error.plugins.were.not.loaded", e.getMessage()));
      getLogger().info(e);
      return findCorePlugin(pluginDescriptors);
    }
    return pluginDescriptors;
  }
Exemple #3
1
 /**
  * Given a string, return an array of tokens. The separator can be escaped with the '\' character.
  * The '\' character may also be escaped by the '\' character.
  *
  * @param s the string to tokenize.
  * @param separator the separator char.
  * @param maxTokens the maxmimum number of tokens returned. If the max is reached, the remaining
  *     part of s is appended to the end of the last token.
  * @return an array of tokens.
  */
 public static String[] tokenize(String s, char separator, int maxTokens) {
   List tokens = new ArrayList();
   StringBuilder token = new StringBuilder();
   boolean prevIsEscapeChar = false;
   for (int i = 0; i < s.length(); i += Character.charCount(i)) {
     int currentChar = s.codePointAt(i);
     if (prevIsEscapeChar) {
       // Case 1:  escaped character
       token.appendCodePoint(currentChar);
       prevIsEscapeChar = false;
     } else if (currentChar == separator && tokens.size() < maxTokens - 1) {
       // Case 2:  separator
       tokens.add(token.toString());
       token = new StringBuilder();
     } else if (currentChar == '\\') {
       // Case 3:  escape character
       prevIsEscapeChar = true;
     } else {
       // Case 4:  regular character
       token.appendCodePoint(currentChar);
     }
   }
   if (token.length() > 0) {
     tokens.add(token.toString());
   }
   return (String[]) tokens.toArray(new String[] {});
 }
 @Override
 protected ObjectMapper createMapper(
     String name,
     String fullPath,
     boolean enabled,
     Nested nested,
     Dynamic dynamic,
     ContentPath.Type pathType,
     Map<String, Mapper> mappers,
     @Nullable @IndexSettings Settings settings) {
   assert !nested.isNested();
   FormatDateTimeFormatter[] dates = null;
   if (dynamicDateTimeFormatters == null) {
     dates = new FormatDateTimeFormatter[0];
   } else if (dynamicDateTimeFormatters.isEmpty()) {
     // add the default one
     dates = Defaults.DYNAMIC_DATE_TIME_FORMATTERS;
   } else {
     dates =
         dynamicDateTimeFormatters.toArray(
             new FormatDateTimeFormatter[dynamicDateTimeFormatters.size()]);
   }
   return new RootObjectMapper(
       name,
       enabled,
       dynamic,
       pathType,
       mappers,
       dates,
       dynamicTemplates.toArray(new DynamicTemplate[dynamicTemplates.size()]),
       dateDetection,
       numericDetection,
       settings);
 }
Exemple #5
0
  /** Initialize mappings, during the first request. */
  protected void initializeMappings() {

    String viewMappings = webConfig.getOptionValue(WebContextInitParameter.FaceletsViewMappings);
    if ((viewMappings != null) && (viewMappings.length() > 0)) {
      String[] mappingsArray = Util.split(viewMappings, ";");

      List<String> extensionsList = new ArrayList<String>(mappingsArray.length);
      List<String> prefixesList = new ArrayList<String>(mappingsArray.length);

      for (int i = 0; i < mappingsArray.length; i++) {
        String mapping = mappingsArray[i].trim();
        int mappingLength = mapping.length();
        if (mappingLength <= 1) {
          continue;
        }

        if (mapping.charAt(0) == '*') {
          extensionsList.add(mapping.substring(1));
        } else if (mapping.charAt(mappingLength - 1) == '*') {
          prefixesList.add(mapping.substring(0, mappingLength - 1));
        }
      }

      extensionsArray = new String[extensionsList.size()];
      extensionsList.toArray(extensionsArray);

      prefixesArray = new String[prefixesList.size()];
      prefixesList.toArray(prefixesArray);
    }
  }
  /**
   * Creates a new <code>AnnotationDirectoryItem</code> with the given values
   *
   * @param dexFile The <code>DexFile</code> that this item belongs to
   * @param classAnnotations The annotations associated with the overall class
   * @param fieldAnnotations A list of <code>FieldAnnotation</code> objects that contain the field
   *     annotations for this class
   * @param methodAnnotations A list of <code>MethodAnnotation</code> objects that contain the
   *     method annotations for this class
   * @param parameterAnnotations A list of <code>ParameterAnnotation</code> objects that contain the
   *     parameter annotations for the methods in this class
   */
  private AnnotationDirectoryItem(
      DexFile dexFile,
      @Nullable AnnotationSetItem classAnnotations,
      @Nullable List<FieldAnnotation> fieldAnnotations,
      @Nullable List<MethodAnnotation> methodAnnotations,
      @Nullable List<ParameterAnnotation> parameterAnnotations) {
    super(dexFile);
    this.classAnnotations = classAnnotations;

    if (fieldAnnotations == null || fieldAnnotations.size() == 0) {
      this.fieldAnnotations = null;
    } else {
      this.fieldAnnotations = new FieldAnnotation[fieldAnnotations.size()];
      this.fieldAnnotations = fieldAnnotations.toArray(this.fieldAnnotations);
      Arrays.sort(this.fieldAnnotations);
    }

    if (methodAnnotations == null || methodAnnotations.size() == 0) {
      this.methodAnnotations = null;
    } else {
      this.methodAnnotations = new MethodAnnotation[methodAnnotations.size()];
      this.methodAnnotations = methodAnnotations.toArray(this.methodAnnotations);
      Arrays.sort(this.methodAnnotations);
    }

    if (parameterAnnotations == null || parameterAnnotations.size() == 0) {
      this.parameterAnnotations = null;
    } else {
      this.parameterAnnotations = new ParameterAnnotation[parameterAnnotations.size()];
      this.parameterAnnotations = parameterAnnotations.toArray(this.parameterAnnotations);
      Arrays.sort(this.parameterAnnotations);
    }
  }
  /**
   * Builds an {@link AFPChain} from already-matched arrays of atoms and residues.
   *
   * @param ca1 An array of atoms in the first structure
   * @param ca2 An array of atoms in the second structure
   * @param residues1 An array of {@link ResidueNumber ResidueNumbers} in the first structure that
   *     are aligned. Only null ResidueNumbers are considered to be unaligned
   * @param residues2 An array of {@link ResidueNumber ResidueNumbers} in the second structure that
   *     are aligned. Only null ResidueNumbers are considered to be unaligned
   * @throws StructureException
   */
  private static AFPChain buildAlignment(
      Atom[] ca1, Atom[] ca2, ResidueNumber[] residues1, ResidueNumber[] residues2)
      throws StructureException {

    // remove any gap
    // this includes the ones introduced by the nullifying above
    List<ResidueNumber> alignedResiduesList1 = new ArrayList<ResidueNumber>();
    List<ResidueNumber> alignedResiduesList2 = new ArrayList<ResidueNumber>();
    for (int i = 0; i < residues1.length; i++) {
      if (residues1[i] != null && residues2[i] != null) {
        alignedResiduesList1.add(residues1[i]);
        alignedResiduesList2.add(residues2[i]);
      }
    }

    ResidueNumber[] alignedResidues1 =
        alignedResiduesList1.toArray(new ResidueNumber[alignedResiduesList1.size()]);
    ResidueNumber[] alignedResidues2 =
        alignedResiduesList2.toArray(new ResidueNumber[alignedResiduesList2.size()]);

    AFPChain afpChain = AlignmentTools.createAFPChain(ca1, ca2, alignedResidues1, alignedResidues2);
    afpChain.setAlgorithmName("unknown");

    AlignmentTools.updateSuperposition(afpChain, ca1, ca2);

    afpChain.setBlockSize(new int[] {afpChain.getNrEQR()});
    afpChain.setBlockRmsd(new double[] {afpChain.getTotalRmsdOpt()});
    afpChain.setBlockGap(new int[] {afpChain.getGapLen()});

    return afpChain;
  }
  public static final AccountTypeWS getWS(
      Integer id,
      Integer entityId,
      String invoiceDesign,
      Date dateCreated,
      BigDecimal creditNotificationLimit1,
      BigDecimal creditNotificationLimit2,
      BigDecimal creditLimit,
      InvoiceDeliveryMethodDTO invoiceDeliveryMethod,
      Integer currencyId,
      Integer languageId,
      String description,
      MainSubscriptionWS mainSubscription,
      Set<AccountInformationTypeDTO> informationTypes,
      Set<PaymentMethodTypeDTO> paymentMethodTypes,
      Integer preferredNotificationAitId) {

    AccountTypeWS ws = new AccountTypeWS();
    ws.setId(id);
    ws.setEntityId(entityId);
    ws.setInvoiceDesign(invoiceDesign);
    ws.setDateCreated(dateCreated);
    ws.setCreditNotificationLimit1(
        creditNotificationLimit1 != null ? creditNotificationLimit1.toString() : null);
    ws.setCreditNotificationLimit2(
        creditNotificationLimit2 != null ? creditNotificationLimit2.toString() : null);
    ws.setCreditLimit(creditLimit != null ? creditLimit.toString() : null);
    ws.setInvoiceDeliveryMethodId(
        invoiceDeliveryMethod != null ? invoiceDeliveryMethod.getId() : null);
    ws.setCurrencyId(currencyId);
    ws.setLanguageId(languageId);
    ws.setMainSubscription(mainSubscription);

    if (description != null) {
      ws.setName(description, Constants.LANGUAGE_ENGLISH_ID);
    }

    if (null != informationTypes && informationTypes.size() > 0) {
      List<Integer> informationTypeIds = new ArrayList<Integer>();
      for (AccountInformationTypeDTO ait : informationTypes) {
        informationTypeIds.add(ait.getId());
      }
      if (!informationTypeIds.isEmpty()) {
        ws.setInformationTypeIds(
            informationTypeIds.toArray(new Integer[informationTypeIds.size()]));
      }
    }

    if (null != paymentMethodTypes && paymentMethodTypes.size() > 0) {
      List<Integer> paymentMethodTypeIds = new ArrayList<Integer>(0);
      for (PaymentMethodTypeDTO paymentMethodType : paymentMethodTypes) {
        paymentMethodTypeIds.add(paymentMethodType.getId());
      }
      ws.setPaymentMethodTypeIds(
          paymentMethodTypeIds.toArray(new Integer[paymentMethodTypeIds.size()]));
    }

    ws.setpreferredNotificationAitId(preferredNotificationAitId);
    return ws;
  }
Exemple #9
0
 @org.junit.Test
 public void testUnmanagedClasspath() {
   List<Object> list1 = WrapUtil.toList("a", new Object());
   assertSame(test, test.unmanagedClasspath(list1.toArray(new Object[list1.size()])));
   assertEquals(list1, test.getUnmanagedClasspath());
   List list2 = WrapUtil.toList(WrapUtil.toList("b", "c"));
   test.unmanagedClasspath(list2.toArray(new Object[list2.size()]));
   assertEquals(GUtil.addLists(list1, GUtil.flatten(list2)), test.getUnmanagedClasspath());
 }
Exemple #10
0
 public static void main(String[] args) {
   Random rand = new Random(47);
   List<Pet> pets = Pets.arrayList(7);
   print("1: " + pets);
   Hamster h = new Hamster();
   pets.add(h); // Automatically resizes
   print("2: " + pets);
   print("3: " + pets.contains(h));
   pets.remove(h); // Remove by object
   Pet p = pets.get(2);
   print("4: " + p + " " + pets.indexOf(p));
   Pet cymric = new Cymric();
   print("5: " + pets.indexOf(cymric));
   print("6: " + pets.remove(cymric));
   // Must be the exact object:
   print("7: " + pets.remove(p));
   print("8: " + pets);
   pets.add(3, new Mouse()); // Insert at an index
   print("9: " + pets);
   List<Pet> sub = pets.subList(1, 4);
   print("subList: " + sub);
   print("10: " + pets.containsAll(sub));
   Collections.sort(sub); // In-place sort
   print("sorted subList: " + sub);
   // Order is not important in containsAll():
   print("11: " + pets.containsAll(sub));
   Collections.shuffle(sub, rand); // Mix it up
   print("shuffled subList: " + sub);
   print("12: " + pets.containsAll(sub));
   List<Pet> copy = new ArrayList<Pet>(pets);
   sub = Arrays.asList(pets.get(1), pets.get(4));
   print("sub: " + sub);
   copy.retainAll(sub);
   print("13: " + copy);
   copy = new ArrayList<Pet>(pets); // Get a fresh copy
   copy.remove(2); // Remove by index
   print("14: " + copy);
   copy.removeAll(sub); // Only removes exact objects
   print("15: " + copy);
   copy.set(1, new Mouse()); // Replace an element
   print("16: " + copy);
   copy.addAll(2, sub); // Insert a list in the middle
   print("17: " + copy);
   print("18: " + pets.isEmpty());
   pets.clear(); // Remove all elements
   print("19: " + pets);
   print("20: " + pets.isEmpty());
   pets.addAll(Pets.arrayList(4));
   print("21: " + pets);
   Object[] o = pets.toArray();
   print("22: " + o[3]);
   Pet[] pa = pets.toArray(new Pet[0]);
   print("23: " + pa[3].id());
 }
Exemple #11
0
 private static void writeBlocksToNBT(
     NBTTagCompound tagCompound, BlockMeta[] blocks, String name) {
   List<Integer> ids = new ArrayList<Integer>(blocks.length);
   List<Integer> meta = new ArrayList<Integer>(blocks.length);
   for (BlockMeta t : blocks) {
     ids.add(Block.blockRegistry.getIDForObject(t.getBlock()));
     meta.add((int) t.getMeta());
   }
   tagCompound.setIntArray(name, ArrayUtils.toPrimitive(ids.toArray(new Integer[ids.size()])));
   tagCompound.setIntArray(
       name + "_meta", ArrayUtils.toPrimitive(meta.toArray(new Integer[meta.size()])));
 }
  // implement RelOptRule
  public void onMatch(RelOptRuleCall call) {
    CalcRel calcRel = (CalcRel) call.rels[0];
    RexProgram program = calcRel.getProgram();

    // check the projection
    List<Integer> projOrdinals = new ArrayList<Integer>();
    RelDataType outputRowType = isProjectSimple(calcRel, projOrdinals);
    if (outputRowType == null) {
      return;
    }

    RexLocalRef condition = program.getCondition();
    CompOperatorEnum compOp = CompOperatorEnum.COMP_NOOP;
    Integer[] filterOrdinals = {};
    List<RexLiteral> filterLiterals = new ArrayList<RexLiteral>();

    // check the condition
    if (condition != null) {
      RexNode filterExprs = program.expandLocalRef(condition);
      List<Integer> filterList = new ArrayList<Integer>();

      List<CompOperatorEnum> op = new ArrayList<CompOperatorEnum>();
      if (!isConditionSimple(calcRel, filterExprs, filterList, filterLiterals, op)) {
        return;
      }

      compOp = op.get(0);
      filterOrdinals = filterList.toArray(new Integer[filterList.size()]);
    }

    RelNode fennelInput =
        mergeTraitsAndConvert(
            calcRel.getTraits(), FennelRel.FENNEL_EXEC_CONVENTION, calcRel.getChild());
    if (fennelInput == null) {
      return;
    }

    Integer[] projection = projOrdinals.toArray(new Integer[projOrdinals.size()]);
    FennelReshapeRel reshapeRel =
        new FennelReshapeRel(
            calcRel.getCluster(),
            fennelInput,
            projection,
            outputRowType,
            compOp,
            filterOrdinals,
            filterLiterals,
            new FennelRelParamId[] {},
            new Integer[] {},
            null);

    call.transformTo(reshapeRel);
  }
  /** Return class names form jet sources in given scope which should be visible as Java classes. */
  @NotNull
  @Override
  public PsiClass[] getClassesByName(
      @NotNull @NonNls String name, @NotNull GlobalSearchScope scope) {
    List<PsiClass> result = new ArrayList<PsiClass>();

    IDELightClassGenerationSupport lightClassGenerationSupport =
        IDELightClassGenerationSupport.getInstanceForIDE(project);
    MultiMap<String, FqName> packageClasses =
        lightClassGenerationSupport.getAllPackageClasses(scope);

    // .namespace classes can not be indexed, since they have no explicit declarations
    Collection<FqName> fqNames = packageClasses.get(name);
    if (!fqNames.isEmpty()) {
      for (FqName fqName : fqNames) {
        PsiClass psiClass =
            JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope);
        if (psiClass != null) {
          result.add(psiClass);
        }
      }
    }

    // Quick check for classes from getAllClassNames()
    Collection<JetClassOrObject> classOrObjects =
        JetShortClassNameIndex.getInstance().get(name, project, scope);
    if (classOrObjects.isEmpty()) {
      return result.toArray(new PsiClass[result.size()]);
    }

    for (JetClassOrObject classOrObject : classOrObjects) {
      FqName fqName = JetPsiUtil.getFQName(classOrObject);
      if (fqName != null) {
        assert fqName.shortName().getName().equals(name)
            : "A declaration obtained from index has non-matching name:\n"
                + "in index: "
                + name
                + "\n"
                + "declared: "
                + fqName.shortName()
                + "("
                + fqName
                + ")";
        PsiClass psiClass =
            JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope);
        if (psiClass != null) {
          result.add(psiClass);
        }
      }
    }

    return result.toArray(new PsiClass[result.size()]);
  }
 public static Predicate[] networkPermissionsPredicates(
     CriteriaBuilder cb, Root<?> from, Set<AccessKeyPermission> permissions) {
   List<Predicate> predicates = new ArrayList<>();
   for (AccessKeyBasedFilterForDevices extraFilter :
       AccessKeyBasedFilterForDevices.createExtraFilters(permissions)) {
     List<Predicate> filter = new ArrayList<>();
     if (extraFilter.getNetworkIds() != null) {
       filter.add(from.get("id").in(extraFilter.getNetworkIds()));
     }
     predicates.add(cb.and(filter.toArray(new Predicate[filter.size()])));
   }
   return predicates.toArray(new Predicate[predicates.size()]);
 }
  private static void processCallerMethod(
      JavaChangeInfo changeInfo,
      PsiMethod caller,
      PsiMethod baseMethod,
      boolean toInsertParams,
      boolean toInsertThrows)
      throws IncorrectOperationException {
    LOG.assertTrue(toInsertParams || toInsertThrows);
    if (toInsertParams) {
      List<PsiParameter> newParameters = new ArrayList<PsiParameter>();
      ContainerUtil.addAll(newParameters, caller.getParameterList().getParameters());
      final JavaParameterInfo[] primaryNewParms = changeInfo.getNewParameters();
      PsiSubstitutor substitutor =
          baseMethod == null
              ? PsiSubstitutor.EMPTY
              : ChangeSignatureProcessor.calculateSubstitutor(caller, baseMethod);
      for (JavaParameterInfo info : primaryNewParms) {
        if (info.getOldIndex() < 0)
          newParameters.add(createNewParameter(changeInfo, info, substitutor));
      }
      PsiParameter[] arrayed = newParameters.toArray(new PsiParameter[newParameters.size()]);
      boolean[] toRemoveParm = new boolean[arrayed.length];
      Arrays.fill(toRemoveParm, false);
      resolveParameterVsFieldsConflicts(arrayed, caller, caller.getParameterList(), toRemoveParm);
    }

    if (toInsertThrows) {
      List<PsiJavaCodeReferenceElement> newThrowns = new ArrayList<PsiJavaCodeReferenceElement>();
      final PsiReferenceList throwsList = caller.getThrowsList();
      ContainerUtil.addAll(newThrowns, throwsList.getReferenceElements());
      final ThrownExceptionInfo[] primaryNewExns = changeInfo.getNewExceptions();
      for (ThrownExceptionInfo thrownExceptionInfo : primaryNewExns) {
        if (thrownExceptionInfo.getOldIndex() < 0) {
          final PsiClassType type =
              (PsiClassType) thrownExceptionInfo.createType(caller, caller.getManager());
          final PsiJavaCodeReferenceElement ref =
              JavaPsiFacade.getInstance(caller.getProject())
                  .getElementFactory()
                  .createReferenceElementByType(type);
          newThrowns.add(ref);
        }
      }
      PsiJavaCodeReferenceElement[] arrayed =
          newThrowns.toArray(new PsiJavaCodeReferenceElement[newThrowns.size()]);
      boolean[] toRemoveParm = new boolean[arrayed.length];
      Arrays.fill(toRemoveParm, false);
      ChangeSignatureUtil.synchronizeList(
          throwsList, Arrays.asList(arrayed), ThrowsList.INSTANCE, toRemoveParm);
    }
  }
 public TreeNode[] findChildrenBySuffix(String suffix) {
   if (suffix == null) {
     List<TreeNode> lst = new ArrayList<TreeNode>();
     for (List<TreeNodeImpl> lst1 : childs.values()) {
       lst.addAll(lst1);
     }
     return lst.toArray(new TreeNode[lst.size()]);
   } else {
     List<TreeNodeImpl> lst = childs.get(suffix);
     if (lst != null) {
       return lst.toArray(new TreeNode[lst.size()]);
     }
   }
   return new TreeNode[0];
 }
  @NotNull
  public ContextItem[] findCtxItems(String startCtxPath, String name) {
    String[] path = startCtxPath.split("/");
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return new ContextItem[0];
      }
    }

    List<ContextItem> out = new ArrayList<ContextItem>();
    TreeNode[] children =
        name == null
            ? cycled.getChildren().toArray(new TreeNode[0])
            : cycled.findChildrenBySuffix(name);
    for (TreeNode n : children) {
      // todo -- revise to replace using value directly with a TreeNode instance
      out.add(new ContextItemImpl(n.getPath(), n.getValue()));
    }

    return out.toArray(new ContextItem[out.size()]);
  }
Exemple #18
0
 Field[] keyFields() {
   Class c = clazz;
   try {
     List<Field> fields = new ArrayList<Field>();
     while (!c.equals(Object.class)) {
       for (Field field : c.getDeclaredFields()) {
         // TODO: add cashe field->isAnnotationPresent
         if (InternalCache.isEnableAnnotationPresent()) {
           if (InternalCache.isAnnotationPresent(Id.class, field)
               || InternalCache.isAnnotationPresent(EmbeddedId.class, field)) {
             field.setAccessible(true);
             fields.add(field);
           }
         } else {
           if (field.isAnnotationPresent(Id.class)
               || field.isAnnotationPresent(EmbeddedId.class)) {
             field.setAccessible(true);
             fields.add(field);
           }
         }
       }
       c = c.getSuperclass();
     }
     final Field[] f = fields.toArray(new Field[fields.size()]);
     if (f.length == 0) {
       throw new UnexpectedException("Cannot get the object @Id for an object of type " + clazz);
     }
     return f;
   } catch (Exception e) {
     throw new UnexpectedException(
         "Error while determining the object @Id for an object of type " + clazz);
   }
 }
  private static PsiAnnotationMemberValue[] readFromClass(
      @NonNls String attributeName, @NotNull PsiAnnotation magic, PsiType type) {
    PsiAnnotationMemberValue fromClassAttr = magic.findAttributeValue(attributeName);
    PsiType fromClassType =
        fromClassAttr instanceof PsiClassObjectAccessExpression
            ? ((PsiClassObjectAccessExpression) fromClassAttr).getOperand().getType()
            : null;
    PsiClass fromClass =
        fromClassType instanceof PsiClassType ? ((PsiClassType) fromClassType).resolve() : null;
    if (fromClass == null) return null;
    String fqn = fromClass.getQualifiedName();
    if (fqn == null) return null;
    List<PsiAnnotationMemberValue> constants = new ArrayList<PsiAnnotationMemberValue>();
    for (PsiField field : fromClass.getFields()) {
      if (!field.hasModifierProperty(PsiModifier.PUBLIC)
          || !field.hasModifierProperty(PsiModifier.STATIC)
          || !field.hasModifierProperty(PsiModifier.FINAL)) continue;
      PsiType fieldType = field.getType();
      if (!Comparing.equal(fieldType, type)) continue;
      PsiAssignmentExpression e =
          (PsiAssignmentExpression)
              JavaPsiFacade.getElementFactory(field.getProject())
                  .createExpressionFromText("x=" + fqn + "." + field.getName(), field);
      PsiReferenceExpression refToField = (PsiReferenceExpression) e.getRExpression();
      constants.add(refToField);
    }
    if (constants.isEmpty()) return null;

    return constants.toArray(new PsiAnnotationMemberValue[constants.size()]);
  }
 @NotNull
 public static PsiClassType[] getImplementsListTypes(GrTypeDefinition grType) {
   Set<PsiClass> visited = new HashSet<PsiClass>();
   List<PsiClassType> result = new ArrayList<PsiClassType>();
   getImplementListsInner(grType, result, visited);
   return result.toArray(new PsiClassType[result.size()]);
 }
Exemple #21
0
    @Override
    public IndexResponse getIndexByColumnNames(
        RpcController controller, GetIndexByColumnNamesRequest request) throws ServiceException {

      TableIdentifierProto identifier = request.getTableIdentifier();
      String databaseName = identifier.getDatabaseName();
      String tableName = identifier.getTableName();
      List<String> columnNamesList = request.getColumnNamesList();
      String[] columnNames = new String[columnNamesList.size()];
      columnNames = columnNamesList.toArray(columnNames);

      rlock.lock();
      try {

        if (!store.existIndexByColumns(databaseName, tableName, columnNames)) {
          return IndexResponse.newBuilder()
              .setState(errUndefinedIndex(tableName, columnNamesList))
              .build();
        }
        return IndexResponse.newBuilder()
            .setState(OK)
            .setIndexDesc(store.getIndexByColumns(databaseName, tableName, columnNames))
            .build();
      } catch (Throwable t) {
        printStackTraceIfError(LOG, t);

        return IndexResponse.newBuilder().setState(returnError(t)).build();
      } finally {
        rlock.unlock();
      }
    }
  public TreeNode[] findNodeInContext(String startCtxPath, @Nullable final String name) {
    final List<TreeNode> out = new ArrayList<TreeNode>();
    root.iterateThruContext(
        startCtxPath,
        new TreeNodeRoot.TreeNodeHandler2() {
          public boolean handleNode(int ctxPathCounter, TreeNode node) {
            if (name == null || node.getName().equalsIgnoreCase(name)) {
              out.add(node);
            }
            return true;
          }
        });

    return out.toArray(new TreeNode[out.size()]);
    /*
            String[] path = startCtxPath.split("/");
            int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

            TreeNode cycled = root;
            for (int i = startWith; i < path.length; i++) {
                String encodedName = "/" + path[i];
                cycled = cycled.findChildByEncodedName(encodedName);
                if (cycled == null) {
                    return new TreeNode[0];
                }
            }

            return cycled.findChildrenBySuffix(name);
    */
  }
Exemple #23
0
  public void init(String[] args) throws UserError {
    Context.reset();
    CommandLineParser globalParser = new GnuParser();

    List<String> globalArgs = new ArrayList<String>();

    boolean inGlobal = true;
    for (String arg : args) {
      if (inGlobal) {
        if (arg.startsWith("--")) {
          globalArgs.add(arg);
        } else {
          this.command = arg;
          inGlobal = false;
        }
      } else {
        commandArgs.add(arg);
      }
    }

    try {
      this.globalArguments =
          globalParser.parse(globalOptions, globalArgs.toArray(new String[globalArgs.size()]));
    } catch (ParseException e) {
      throw new UserError("Error parsing global command line argument: " + e.getMessage());
    }
  }
Exemple #24
0
  public static String[] listFiles(File dir, Boolean includeSubDirs) throws IOException {
    FileFilter fileFilter =
        new FileFilter() {
          public boolean accept(File file) {
            return file.isDirectory();
          }
        };
    File[] subFolders = dir.listFiles(fileFilter);

    List<String> files = new ArrayList<String>();

    List<File> fileArray =
        new ArrayList<File>(
            FileUtils.listFiles(
                dir, TrueFileFilter.INSTANCE, includeSubDirs ? TrueFileFilter.INSTANCE : null));

    for (File file : fileArray) {
      if (file.isFile()) {
        if (includeSubDirs && containsParentFolder(file, subFolders)) {
          files.add(file.getParentFile().getName() + File.separator + file.getName());
        } else {
          files.add(file.getName());
        }
      }
    }

    return (String[]) files.toArray(new String[0]);
  }
Exemple #25
0
    @Override
    public ReturnState existIndexByColumnNames(
        RpcController controller, GetIndexByColumnNamesRequest request) throws ServiceException {

      TableIdentifierProto identifier = request.getTableIdentifier();
      String databaseName = identifier.getDatabaseName();
      String tableName = identifier.getTableName();
      List<String> columnNames = request.getColumnNamesList();

      try {
        // linked meta data do not support index. The request will be failed.
        if (linkedMetadataManager.existsDatabase(databaseName)) {
          return errUndefinedIndex(tableName);
        }
      } catch (Throwable t) {
        printStackTraceIfError(LOG, t);
        return returnError(t);
      }

      rlock.lock();
      try {
        return store.existIndexByColumns(
                databaseName, tableName, columnNames.toArray(new String[columnNames.size()]))
            ? OK
            : errUndefinedIndex(tableName, columnNames);

      } catch (Throwable t) {
        printStackTraceIfError(LOG, t);
        return returnError(t);
      } finally {
        rlock.unlock();
      }
    }
  public static boolean canHarvestBlock(Block block, EntityPlayer player, int metadata) {
    if (block.blockMaterial.isToolNotRequired()) {
      return true;
    }

    ItemStack stack = player.inventory.getCurrentItem();
    if (stack == null) {
      return player.canHarvestBlock(block);
    }

    List info = toolClasses.get(stack.getItem());
    if (info == null) {
      return player.canHarvestBlock(block);
    }

    Object[] tmp = info.toArray();
    String toolClass = (String) tmp[0];
    int harvestLevel = (Integer) tmp[1];

    Integer blockHarvestLevel = toolHarvestLevels.get(Arrays.asList(block, metadata, toolClass));
    if (blockHarvestLevel == null) {
      return player.canHarvestBlock(block);
    }

    if (blockHarvestLevel > harvestLevel) {
      return false;
    }
    return true;
  }
  @DataProvider(name = "AdaptorGetter")
  public Object[][] makeActiveRegionCutTests() {
    final List<Object[]> tests = new LinkedList<Object[]>();

    tests.add(
        new Object[] {
          new GetAdaptorFunc() {
            @Override
            public int getAdaptor(final GATKSAMRecord record) {
              return ReadUtils.getAdaptorBoundary(record);
            }
          }
        });

    tests.add(
        new Object[] {
          new GetAdaptorFunc() {
            @Override
            public int getAdaptor(final GATKSAMRecord record) {
              return record.getAdaptorBoundary();
            }
          }
        });

    return tests.toArray(new Object[][] {});
  }
 // spread expressions
 public static Object[] despreadList(Object[] args, Object[] spreads, int[] positions) {
   List ret = new ArrayList();
   int argsPos = 0;
   int spreadPos = 0;
   for (int pos = 0; pos < positions.length; pos++) {
     for (; argsPos < positions[pos]; argsPos++) {
       ret.add(args[argsPos]);
     }
     Object value = spreads[spreadPos];
     if (value == null) {
       ret.add(null);
     } else if (value instanceof List) {
       ret.addAll((List) value);
     } else if (value.getClass().isArray()) {
       ret.addAll(DefaultTypeTransformation.primitiveArrayToList(value));
     } else {
       throw new IllegalArgumentException(
           "cannot spread the type " + value.getClass().getName() + " with value " + value);
     }
     spreadPos++;
   }
   for (; argsPos < args.length; argsPos++) {
     ret.add(args[argsPos]);
   }
   return ret.toArray();
 }
 /** populates a request object (pre-populated with defaults) based on a parser. */
 public static void parseRequest(TermVectorRequest termVectorRequest, XContentParser parser)
     throws IOException {
   XContentParser.Token token;
   String currentFieldName = null;
   List<String> fields = new ArrayList<>();
   while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
     if (token == XContentParser.Token.FIELD_NAME) {
       currentFieldName = parser.currentName();
     } else if (currentFieldName != null) {
       if (currentFieldName.equals("fields")) {
         if (token == XContentParser.Token.START_ARRAY) {
           while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
             fields.add(parser.text());
           }
         } else {
           throw new ElasticsearchParseException(
               "The parameter fields must be given as an array! Use syntax : \"fields\" : [\"field1\", \"field2\",...]");
         }
       } else if (currentFieldName.equals("offsets")) {
         termVectorRequest.offsets(parser.booleanValue());
       } else if (currentFieldName.equals("positions")) {
         termVectorRequest.positions(parser.booleanValue());
       } else if (currentFieldName.equals("payloads")) {
         termVectorRequest.payloads(parser.booleanValue());
       } else if (currentFieldName.equals("term_statistics")
           || currentFieldName.equals("termStatistics")) {
         termVectorRequest.termStatistics(parser.booleanValue());
       } else if (currentFieldName.equals("field_statistics")
           || currentFieldName.equals("fieldStatistics")) {
         termVectorRequest.fieldStatistics(parser.booleanValue());
       } else if ("_index"
           .equals(currentFieldName)) { // the following is important for multi request parsing.
         termVectorRequest.index = parser.text();
       } else if ("_type".equals(currentFieldName)) {
         termVectorRequest.type = parser.text();
       } else if ("_id".equals(currentFieldName)) {
         if (termVectorRequest.doc != null) {
           throw new ElasticsearchParseException(
               "Either \"id\" or \"doc\" can be specified, but not both!");
         }
         termVectorRequest.id = parser.text();
       } else if ("doc".equals(currentFieldName)) {
         if (termVectorRequest.id != null) {
           throw new ElasticsearchParseException(
               "Either \"id\" or \"doc\" can be specified, but not both!");
         }
         termVectorRequest.doc(jsonBuilder().copyCurrentStructure(parser));
       } else if ("_routing".equals(currentFieldName) || "routing".equals(currentFieldName)) {
         termVectorRequest.routing = parser.text();
       } else {
         throw new ElasticsearchParseException(
             "The parameter " + currentFieldName + " is not valid for term vector request!");
       }
     }
   }
   if (fields.size() > 0) {
     String[] fieldsAsArray = new String[fields.size()];
     termVectorRequest.selectedFields(fields.toArray(fieldsAsArray));
   }
 }
  /**
   * Returns paths constructed by rewriting pathInfo using rules from the hosted site's mappings.
   * Paths are ordered from most to least specific match.
   *
   * @param site The hosted site.
   * @param pathInfo Path to be rewritten.
   * @param queryString
   * @return The rewritten path. May be either:
   *     <ul>
   *       <li>A path to a file in the Orion workspace, eg. <code>/ProjectA/foo/bar.txt</code>
   *       <li>An absolute URL pointing to another site, eg. <code>http://foo.com/bar.txt</code>
   *     </ul>
   *
   * @return The rewritten paths.
   * @throws URISyntaxException
   */
  private URI[] getMapped(IHostedSite site, IPath pathInfo, String queryString)
      throws URISyntaxException {
    final Map<String, List<String>> map = site.getMappings();
    final IPath originalPath = pathInfo;
    IPath path = originalPath.removeTrailingSeparator();

    List<URI> uris = new ArrayList<URI>();
    String rest = null;
    final int count = path.segmentCount();
    for (int i = 0; i <= count; i++) {
      List<String> base = map.get(path.toString());
      if (base != null) {
        rest = originalPath.removeFirstSegments(count - i).toString();
        for (int j = 0; j < base.size(); j++) {
          URI uri =
              rest.equals("") ? new URI(base.get(j)) : URIUtil.append(new URI(base.get(j)), rest);
          uris.add(
              new URI(
                  uri.getScheme(),
                  uri.getUserInfo(),
                  uri.getHost(),
                  uri.getPort(),
                  uri.getPath(),
                  queryString,
                  uri.getFragment()));
        }
      }
      path = path.removeLastSegments(1);
    }
    if (uris.size() == 0)
      // No mapping for /
      return null;
    else return uris.toArray(new URI[uris.size()]);
  }