private String toOutputName(String inputResourcePattern) throws IOException { assert inputResourcePattern != null; String patternString = resolve(inputResourcePattern); FilePattern pattern = FilePattern.compile(patternString); if (pattern.containsVariables()) { throw new IOException(MessageFormat.format( Messages.getString("DirectIoTestHelper.errorInputContainUnresolvedVariable"), //$NON-NLS-1$ for (Segment segment : pattern.getSegments()) { if (buf.length() != 0) { buf.append('/');
/** * Compiles pattern expression. * @param patternString pattern expression * @return the compiled object * @throws IllegalArgumentException if pattern is not valid * @see <a href="#pattern-expression">Pattern Expression</a> */ public static FilePattern compile(String patternString) { if (patternString == null) { throw new IllegalArgumentException("patternString must not be null"); //$NON-NLS-1$ } if (patternString.isEmpty()) { throw new IllegalArgumentException("patternString must not be empty"); //$NON-NLS-1$ } List<Segment> segments = compileSegments(patternString); return new FilePattern(segments, patternString); }
/** * Returns a file pattern that is a sequence of this and the given pattern. * @param pattern the target pattern * @return the resolved pattern */ public FilePattern resolve(FilePattern pattern) { if (segments.isEmpty()) { return pattern; } List<FilePattern.Segment> results = new ArrayList<>(); FilePattern prefix = FilePattern.compile(toString()); results.addAll(prefix.getSegments()); results.addAll(pattern.getSegments()); return FilePattern.of(results); }
@Override public <T> ModelInput<T> open( Class<? extends DataFormat<T>> formatClass, String basePath, String resourcePattern) throws IOException { FilePattern bPattern = FilePattern.compile(basePath); if (bPattern.containsVariables()) { throw new IllegalArgumentException(MessageFormat.format( "base path must not contain variables: {0}", basePath)); } FilePattern rPattern = FilePattern.compile(resourcePattern); if (rPattern.containsVariables()) { throw new IllegalArgumentException(MessageFormat.format( "resource pattern must not contain variables: {0}", resourcePattern)); } try { return open0(formatClass, basePath, rPattern); } catch (InterruptedException e) { throw (IOException) new InterruptedIOException().initCause(e); } }
/** * Returns the file pattern. * @return the file pattern */ public FilePattern asFilePattern() { if (segments.isEmpty()) { throw new IllegalStateException(); } else { return FilePattern.compile(getPathString()); } }
/** * Resolves the given path. * @param path the given path * @return the base path, or {@code empty} if it is not a valid base path */ public static Optional<BasePath> parse(String path) { if (isEmpty(path)) { return Optional.of(EMPTY); } FilePattern pattern = FilePattern.compile(path); List<String> results = new ArrayList<>(); for (FilePattern.Segment segment : pattern.getSegments()) { if (isPlain(segment)) { results.add(segment.toString()); } else { return Optional.empty(); } } return Optional.of(new BasePath(results)); }
private static BasePath headOf(FilePattern pattern) { List<String> results = new ArrayList<>(); for (FilePattern.Segment segment : pattern.getSegments()) { if (isPlain(segment)) { results.add(segment.toString()); } else { break; } } return new BasePath(results); }
ArrayList<FilePattern> patterns = new ArrayList<FilePattern>(); patterns.add(new FilePattern(new byte[]{ ... }, "extension")); .... // for other patterns.
private static Segment consumeSegment(Cursor cursor) { assert cursor != null; int first = cursor.get(0); assert first != CHAR_SEPARATOR && first != CHAR_EOF : cursor; // special case if (first == CHAR_ASTERISK && cursor.get(1) == CHAR_ASTERISK && (cursor.get(2) == CHAR_SEPARATOR || cursor.get(2) == CHAR_EOF)) { cursor.skipWhile(CHAR_ASTERISK); cursor.skipWhile(CHAR_SEPARATOR); return Segment.TRAVERSE; } List<PatternElement> elements = consumeElements(cursor); return new Segment(elements); }
/** * Truncates the current target. * @param resourcePattern the target resource pattern * @throws IOException if failed to perform by I/O error * @since 0.7.3 */ public void truncate(String resourcePattern) throws IOException { if (LOG.isDebugEnabled()) { LOG.debug(MessageFormat.format( "Truncating Direct I/O resources: {0}:{1} (id={2})", //$NON-NLS-1$ fullPath, resourcePattern, id)); } try { dataSource.delete(basePath, FilePattern.compile(resourcePattern), true, new Counter()); } catch (InterruptedException e) { throw (IOException) new InterruptedIOException("interrupted").initCause(e); //$NON-NLS-1$ } }
/** * A traverse pattern. */ @Test public void traverse() { FilePattern compiled = FilePattern.compile("**"); List<Segment> segments = compiled.getSegments(); assertThat(segments.size(), is(1)); assertThat(segments.get(0).isTraverse(), is(true)); assertThat(segments.get(0).getElements(), is(kind())); }
/** * Extracts the rest resource pattern of the given path. * @param path the target path * @return the rest resource pattern * @see #headOf(String) */ public Optional<FilePattern> restOf(String path) { if (BasePath.isEmpty(path)) { return Optional.empty(); } FilePattern pattern = FilePattern.compile(path); if (segments.isEmpty()) { return Optional.of(pattern); } BasePath other = headOf(pattern); if (this.isPrefixOf(other) == false) { throw new IllegalArgumentException(MessageFormat.format( "\"{0}\" must be a prefix of the path: {1}", this, path)); } if (segments.size() == pattern.getSegments().size()) { return Optional.empty(); } else { return Optional.of(FilePattern.of(pattern.getSegments().subList( segments.size(), pattern.getSegments().size()))); } }
private FilePattern extractSearchPattern( JobContext context, VariableTable variables, StageInput input) throws IOException { assert context != null; assert input != null; String value = extract(input, DirectDataSourceConstants.KEY_RESOURCE_PATH); value = variables.parse(value); try { FilePattern compiled = FilePattern.compile(value); if (compiled.containsVariables()) { throw new IllegalArgumentException(MessageFormat.format( "Search pattern contains variables: {0}", value)); } return compiled; } catch (IllegalArgumentException e) { throw new IOException(MessageFormat.format( "Invalid resource path pattern: \"{1}\" (path={0})", extractBasePath(input), value), e); } }
LinkedList<Segment> segments = new LinkedList<>(pattern.getSegments()); while (segments.isEmpty() == false) { if (segments.getFirst().isTraverse()) {
/** * Returns a pattern of the given segments. * @param segments the pattern segments * @return the pattern * @since 0.10.0 */ public static FilePattern of(List<? extends Segment> segments) { return new FilePattern( new ArrayList<>(segments), segments.stream().map(Segment::toString).collect(Collectors.joining("/"))); }
/** * A variable pattern. */ @Test public void variable() { FilePattern compiled = FilePattern.compile("${v}"); assertThat(compiled.containsVariables(), is(true)); List<Segment> segments = compiled.getSegments(); assertThat(segments.size(), is(1)); assertThat(segments.get(0).isTraverse(), is(false)); assertThat(segments.get(0).getElements(), is(kind(VARIABLE))); assertThat(segments.get(0).getElements(), is(token("${v}"))); }
/** * Extracts a base path from the given path. * @param path the given path * @return the base path of the given path */ public static BasePath headOf(String path) { if (isEmpty(path)) { return BasePath.EMPTY; } FilePattern pattern = FilePattern.compile(path); return headOf(pattern); }
/** * A contains wildcard pattern. */ @Test public void containsWildcard() { FilePattern compiled = FilePattern.compile("data-*.csv"); List<Segment> segments = compiled.getSegments(); assertThat(segments.size(), is(1)); assertThat(segments.get(0).isTraverse(), is(false)); assertThat(segments.get(0).getElements(), is(kind(TOKEN, WILDCARD, TOKEN))); assertThat(segments.get(0).getElements(), is(token("data-", "*", ".csv"))); }
/** * A token. */ @Test public void token() { FilePattern compiled = FilePattern.compile("a"); assertThat(compiled.containsVariables(), is(false)); List<Segment> segments = compiled.getSegments(); assertThat(segments.size(), is(1)); assertThat(segments.get(0).isTraverse(), is(false)); assertThat(segments.get(0).getElements(), is(kind(TOKEN))); assertThat(segments.get(0).getElements(), is(token("a"))); }
@Override public void checkOutputSpecs(JobContext context) throws IOException, InterruptedException { DirectDataSourceRepository repo = getDataSourceRepository(context); List<OutputSpec> specs = getSpecs(context); for (OutputSpec spec : specs) { try { repo.getContainerPath(spec.basePath); } catch (IOException e) { throw new IOException(MessageFormat.format( "There are no corresponded data sources for the base path: {0}", spec.basePath), e); } for (String pattern : spec.deletePatterns) { try { FilePattern.compile(pattern); } catch (IllegalArgumentException e) { throw new IOException(MessageFormat.format( "Invalid delete pattern: {0}", pattern), e); } } } }