Ejemplo n.º 1
0
  public boolean accept(String name) {
    for (Filter filter : filters) {
      if (filter.accept(name)) return true;
    }

    return false;
  }
Ejemplo n.º 2
0
  private DirFilter getDirFilter() {
    DirFilter deepestDirFilter = new DirFilter(Operator.EQ, preferences.get(Keys.MEDIA_DIR));
    for (Filter<? super Tables.Tracks> filter : getFilters()) {
      final DirFilter finalDeepestDirFilter = deepestDirFilter;
      deepestDirFilter =
          filter.accept(
              new TurtleFilterVisitor<Tables.Tracks, DirFilter>() {
                public DirFilter visit(DirFilter dirFilter) {
                  return finalDeepestDirFilter
                          .getValue()
                          .contains(dirFilter.getValueWithoutWildcards())
                      ? finalDeepestDirFilter
                      : new DirFilter(Operator.EQ, dirFilter.getValueWithoutWildcards());
                }

                public DirFilter visit(NotFilter<? super Tables.Tracks> notFilter) {
                  return finalDeepestDirFilter;
                }

                public <T, Z> DirFilter visit(
                    FieldFilter<? super Tables.Tracks, Z, T> fieldFilter) {
                  return finalDeepestDirFilter;
                }

                public DirFilter visit(FilterSet<? super Tables.Tracks> filterSet) {
                  return finalDeepestDirFilter;
                }
              });
    }
    return deepestDirFilter;
  }
Ejemplo n.º 3
0
 private static void populateClasses(
     final Shell shell, final IParent parent, final List<IType> types, final Filter filter) {
   try {
     for (final IJavaElement element : parent.getChildren()) {
       if (element instanceof IType) {
         final IType type = (IType) element;
         if (type.isClass()
             && type.isStructureKnown()
             && !type.isAnonymous()
             && !type.isLocal()
             && !Flags.isAbstract(type.getFlags())
             && Flags.isPublic(type.getFlags())
             && (filter == null || filter.accept(type))) {
           types.add(type);
         }
       } else if (element instanceof IParent
           && !element.getPath().toString().contains("/test/")
           && (!(element instanceof IPackageFragmentRoot)
               || !((IPackageFragmentRoot) element).isExternal())) {
         populateClasses(shell, (IParent) element, types, filter);
       }
     }
   } catch (final JavaModelException e) {
     Activator.error(e);
   }
 }
Ejemplo n.º 4
0
 public ResourceEntry[] getChildren(Filter filter) {
   ResourceEntry[] children = getChildren();
   List childrenFiltered = new ArrayList();
   for (int i = 0; i < children.length; i++) {
     if (filter.accept(children[i])) childrenFiltered.add(children[i]);
   }
   return (ResourceEntry[]) childrenFiltered.toArray(new ResourceEntry[childrenFiltered.size()]);
 }
 @Override
 public boolean accept(Artifact artifact) {
   for (Filter filter : filters) {
     if (filter.accept(artifact)) {
       return result(true, artifact.toString());
     }
   }
   return result(false, artifact.toString());
 }
 private static List<Integer> copyFiltered(List<Integer> list, Filter<Integer> filter) {
   List<Integer> result = new ArrayList<Integer>();
   for (Integer i : list) {
     if (filter.accept(i)) {
       result.add(i);
     }
   }
   return result;
 }
Ejemplo n.º 7
0
 @Override
 protected void doRun(RunNotifier notifier) {
   try {
     myIgnoringFilter.accept(myRequest);
     myRequest.getRunner().run(notifier);
   } catch (Filter.FilterException e) {
     ignoreRequest(notifier, e);
   }
 }
 /**
  * Gets a friend based on a given filter.
  *
  * @param filter The filter defines conditions that your Friend must meet.
  * @return The first Friend that meets the conditions or null if not found.
  */
 public Friend getFriend(Filter<Friend> filter) {
   for (final RosterEntry e : connection.getRoster().getEntries()) {
     final Friend f = new Friend(this, connection, e);
     if (filter.accept(f)) {
       return f;
     }
   }
   return null;
 }
 @Override
 public boolean accept(DependencyNode node, List<DependencyNode> parents) {
   AntClient.getInstance().log("Filtering - " + super.toString() + "...", Project.MSG_DEBUG);
   for (Filter filter : filters) {
     if (filter.accept(node, parents)) {
       return result(true, node.toString());
     }
   }
   return result(false, node.toString());
 }
 /**
  * Gets a list of your friends based on a given filter.
  *
  * @param filter The filter defines conditions that your Friends must meet.
  * @return A List of your Friends that meet the condition of your Filter
  */
 public List<Friend> getFriends(Filter<Friend> filter) {
   final ArrayList<Friend> friends = new ArrayList<>();
   for (final RosterEntry e : connection.getRoster().getEntries()) {
     final Friend f = new Friend(this, connection, e);
     if (filter.accept(f)) {
       friends.add(f);
     }
   }
   return friends;
 }
Ejemplo n.º 11
0
 XmlNode[] getMatchingChildren(Filter filter) {
   ArrayList rv = new ArrayList();
   NodeList nodes = this.dom.getChildNodes();
   for (int i = 0; i < nodes.getLength(); i++) {
     Node node = nodes.item(i);
     if (filter.accept(node)) {
       rv.add(createImpl(node));
     }
   }
   return (XmlNode[]) rv.toArray(new XmlNode[0]);
 }
  protected void packBundle(ZipOutputStream output, Bundle bundle, String path, Filter filter)
      throws IOException {
    if (filter != null && !filter.accept(path)) {
      log(Level.FINE, "exclude {0}/{1}", new Object[] {bundle.getBundleID(), path});
      return;
    }
    BundleFile bundleFile = bundle.getBundleFile();
    if (bundleFile.isDirectory(path)) {
      List<String> entries = bundleFile.getEntryPaths(path);
      for (String entry : entries) {
        packBundle(output, bundle, entry, filter);
      }
      return;
    }

    // pack the JAR/ZIP
    BundleEntry bundleEntry = bundleFile.getEntry(path);
    if (path.endsWith(".jar") || path.endsWith(".zip")) {
      File tempZipFile = createTempFile(bundleEntry);
      try {
        ZipFile zipFile = new ZipFile(tempZipFile);
        try {
          packZip(output, bundleEntry, zipFile, filter);
        } finally {
          zipFile.close();
        }
      } finally {
        tempZipFile.delete();
      }
      return;
    }

    // pack the normal entry
    if (existingEntries.contains(path)) {
      log(Level.WARNING, "duplicate {0}/{1}", new Object[] {bundle.getBundleID(), path});
      return;
    }
    existingEntries.add(path);

    InputStream input = bundleEntry.getInputStream();
    try {
      ZipEntry zipEntry = new ZipEntry(bundleEntry.getName());
      zipEntry.setTime(bundleEntry.getTime());
      zipEntry.setSize(bundleEntry.getSize());
      output.putNextEntry(zipEntry);
      try {
        copyStream(input, output);
      } finally {
        output.closeEntry();
      }
    } finally {
      input.close();
    }
  }
  @Override
  public final void visit(Set<Instance> resultSet, Filter filter) {
    if (resultSet.contains(this)) {
      return;
    }

    if (filter != null) {
      if (filter.accept(this)) {
        resultSet.add(this);
      }
    } else {
      resultSet.add(this);
    }

    State state = mHeap.mState;
    ClassObj isa = state.findClass(mClassId);
    int[] types = isa.mFieldTypes;
    ByteArrayInputStream bais = new ByteArrayInputStream(mFieldValues);
    DataInputStream dis = new DataInputStream(bais);
    final int N = types.length;

    /*
     * Spin through the list of fields, find all object references,
     * and list ourselves as a reference holder.
     */
    try {
      for (int i = 0; i < N; i++) {
        int type = types[i];
        int size = Types.getTypeSize(type);

        if (type == Types.OBJECT) {
          long id;

          if (size == 4) {
            id = dis.readInt();
          } else {
            id = dis.readLong();
          }

          Instance instance = state.findReference(id);

          if (instance != null) {
            instance.visit(resultSet, filter);
          }
        } else {
          dis.skipBytes(size);
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 14
0
  private Result doFakeAuthorization(PaymentDTOEx payment, String transactionId)
      throws PluggableTaskException {
    CreditCardDTO creditCard = payment.getCreditCard();
    if (creditCard == null || !myFilter.accept(creditCard)) {
      // give real processors a chance
      return new Result(null, true);
    }

    Integer resultId = getProcessResultId(creditCard);
    payment.setPaymentResult(new PaymentResultDAS().find(resultId));
    PaymentAuthorizationDTO authInfo = createAuthorizationDTO(resultId, transactionId);
    storeProcessedAuthorization(payment, authInfo);

    boolean wasProcessed =
        (Constants.RESULT_FAIL.equals(resultId) || Constants.RESULT_OK.equals(resultId));
    boolean shouldCallOthers = !wasProcessed && !myShouldBlockOtherProcessors;
    return new Result(authInfo, shouldCallOthers);
  }
  protected void packZip(
      ZipOutputStream output, BundleEntry bundleEntry, ZipFile zipFile, Filter filter)
      throws IOException {
    Enumeration<? extends ZipEntry> entries = zipFile.entries();
    while (entries.hasMoreElements()) {
      ZipEntry srcEntry = entries.nextElement();
      String entryName = srcEntry.getName();
      if (filter != null && !filter.accept(bundleEntry.getName() + "/" + entryName)) {
        log(
            Level.FINE,
            "exclude {0}/{1}/{2}",
            new Object[] {bundleEntry.getBundleID(), bundleEntry.getName(), entryName});
        continue;
      }
      if (entryName.endsWith("/")) {
        continue;
      }
      if (existingEntries.contains(entryName)) {
        log(
            Level.WARNING,
            "duplicate {0}/{1}/{2}",
            new Object[] {bundleEntry.getBundleID(), bundleEntry.getName(), entryName});
        continue;
      }
      existingEntries.add(entryName);

      ZipEntry tgtEntry = new ZipEntry(entryName);
      tgtEntry.setTime(srcEntry.getTime());
      output.putNextEntry(tgtEntry);
      try {
        InputStream input = zipFile.getInputStream(srcEntry);
        try {
          copyStream(input, output);
        } finally {
          input.close();
        }
      } finally {
        output.closeEntry();
      }
    }
  }