Java Code Examples for java.util.EnumSet#contains()

/**
 * Clear the tracked visited folders & the cached {@link LocalPkgInfo} for the
 * given filter types.
 *
 * @param filters A set of PkgType constants or {@link PkgType#PKG_ALL} to clear everything.
 */
public void clearLocalPkg(@NonNull EnumSet<PkgType> filters) {
    mLegacyBuildTools = null;

    synchronized (mLocalPackages) {
        for (PkgType filter : filters) {
            mVisitedDirs.removeAll(filter);
            mLocalPackages.removeAll(filter);
        }

        // Clear the targets if the platforms or addons are being cleared
        if (filters.contains(PkgType.PKG_PLATFORM) || filters.contains(PkgType.PKG_ADDON)) {
            mCachedMissingTargets = null;
            mCachedTargets = null;
        }
    }
}
 

private static void processDelinquent(final PowerTenant tenant, final Registry registry,
        final Investment currentDelinquent) {
    final long investmentId = currentDelinquent.getId();
    final EnumSet<Category> knownCategories = registry.getCategories(currentDelinquent);
    if (knownCategories.contains(Category.HOPELESS)) {
        LOGGER.debug("Investment #{} may not be promoted anymore.", investmentId);
        return;
    }
    final int daysPastDue = currentDelinquent.getLegalDpd()
        .orElse(0);
    final EnumSet<Category> unusedCategories = EnumSet.complementOf(knownCategories);
    final Optional<Category> firstNextCategory = unusedCategories.stream()
        .filter(c -> c.getThresholdInDays() >= 0) // ignore the DEFAULTED category, which gets special treatment
        .filter(c -> c.getThresholdInDays() <= daysPastDue)
        .max(Comparator.comparing(Category::getThresholdInDays));
    if (firstNextCategory.isPresent()) {
        final Category category = firstNextCategory.get();
        LOGGER.debug("Investment #{} placed to category {}.", investmentId, category);
        category.process(tenant, currentDelinquent);
        registry.addCategory(currentDelinquent, category);
    } else {
        LOGGER.debug("Investment #{} can not yet be promoted to the next category.", investmentId);
    }
}
 

private List<ApplicationReport> getApplicationReports(
    List<ApplicationReport> applicationReports,
    Set<String> applicationTypes, EnumSet<YarnApplicationState> applicationStates) {

  List<ApplicationReport> appReports = new ArrayList<ApplicationReport>();
  for (ApplicationReport appReport : applicationReports) {
    if (applicationTypes != null && !applicationTypes.isEmpty()) {
      if (!applicationTypes.contains(appReport.getApplicationType())) {
        continue;
      }
    }

    if (applicationStates != null && !applicationStates.isEmpty()) {
      if (!applicationStates.contains(appReport.getYarnApplicationState())) {
        continue;
      }
    }
    appReports.add(appReport);
  }
  return appReports;
}
 

/**
 * Set the available technologies for the given player.
 * @param xplayer the player definition
 * @param p the player object to load
 * @param categoryFilter the set of main categories to pick up
 */
private void setTechAvailability(XElement xplayer, Player p, EnumSet<ResearchMainCategory> categoryFilter) {
	XElement xavail0 = xplayer.childElement("available");
	if (xavail0 != null) {
		for (XElement xavail : xavail0.childrenWithName("type")) {
			String id = xavail.get("id");
			ResearchType rt = researches.get(id);
			if (rt == null) {
				System.out.println("WARN | Available technology not found: " + xavail);
			} else 
			if (categoryFilter.contains(rt.category.main)) {
				p.add(rt);
				for (String liste : xavail.get("list", "").split("\\s*,\\s*")) {
					if (liste.length() > 0) {
						ResearchType rt0 = researches.get(liste);
						if (rt0 == null) {
							System.out.println("WARN | available technology not found: " + liste + " in " + xavail);
						} else {
							p.availableLevel(rt).add(rt0);
						}
					}
				}
			}
		}
	}
}
 

void start() {
    if (connected) {
        try {
            EnumSet<UsbSerialPort.ControlLine> controlLines = usbSerialPort.getSupportedControlLines();
            if (!controlLines.contains(UsbSerialPort.ControlLine.RTS)) rtsBtn.setVisibility(View.INVISIBLE);
            if (!controlLines.contains(UsbSerialPort.ControlLine.CTS)) ctsBtn.setVisibility(View.INVISIBLE);
            if (!controlLines.contains(UsbSerialPort.ControlLine.DTR)) dtrBtn.setVisibility(View.INVISIBLE);
            if (!controlLines.contains(UsbSerialPort.ControlLine.DSR)) dsrBtn.setVisibility(View.INVISIBLE);
            if (!controlLines.contains(UsbSerialPort.ControlLine.CD))   cdBtn.setVisibility(View.INVISIBLE);
            if (!controlLines.contains(UsbSerialPort.ControlLine.RI))   riBtn.setVisibility(View.INVISIBLE);
        } catch (IOException e) {
            Toast.makeText(getActivity(), "getSupportedControlLines() failed: " + e.getMessage(), Toast.LENGTH_SHORT).show();
        }
        if (refresh())
            mainLooper.postDelayed(runnable, refreshInterval);
    }
}
 

private boolean isOfKindAndType(TypeMirror type, Element e, EnumSet<ElementKind> kinds, TypeMirror base, Scope scope, Trees trees, Types types) {
    if (type.getKind() != TypeKind.ERROR && kinds.contains(e.getKind())) {
        if (base == null)
            return true;
        if (types.isSubtype(type, base))
            return true;
    }
    if ((e.getKind().isClass() || e.getKind().isInterface()) && 
        (kinds.contains(ANNOTATION_TYPE) || kinds.contains(CLASS) || kinds.contains(ENUM) || kinds.contains(INTERFACE))) {
        DeclaredType dt = (DeclaredType)e.asType();
        for (Element ee : e.getEnclosedElements())
            if (trees.isAccessible(scope, ee, dt) && isOfKindAndType(ee.asType(), ee, kinds, base, scope, trees, types))
                return true;
    }
    return false;
}
 

@Override
void parseRootLoggerElement(final XMLExtendedStreamReader reader, final PathAddress address, final List<ModelNode> operations) throws XMLStreamException {
    // No attributes
    if (reader.getAttributeCount() > 0) {
        throw unexpectedAttribute(reader, 0);
    }

    final ModelNode operation = Util.createAddOperation(address.append(RootLoggerResourceDefinition.NAME, RESOURCE_NAME));
    final EnumSet<Element> encountered = EnumSet.noneOf(Element.class);
    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        final Element element = Element.forName(reader.getLocalName());
        if (encountered.contains(element)) {
            throw duplicateNamedElement(reader, reader.getLocalName());
        }
        encountered.add(element);
        switch (element) {
            case FILTER_SPEC: {
                LoggerAttributes.FILTER_SPEC.parseAndSetParameter(readValueAttribute(reader), operation, reader);
                break;
            }
            case LEVEL: {
                LEVEL.parseAndSetParameter(readNameAttribute(reader), operation, reader);
                break;
            }
            case HANDLERS: {
                parseHandlersElement(element.getDefinition(), operation, reader);
                break;
            }
            default:
                throw unexpectedElement(reader);
        }
    }
    operations.add(operation);
}
 

private static Script script(ExecutionContext cx, ExecutionContext caller, String sourceCode, int flags) {
    try {
        Realm realm = cx.getRealm();
        Source source = evalSource(caller);
        EnumSet<Parser.Option> options = EvalFlags.toOptions(flags);
        EnumSet<Parser.Option> contextOptions = realm.getRuntimeContext().getParserOptions();
        if (contextOptions.contains(Parser.Option.NativeCall)) {
            options.add(Parser.Option.NativeCall);
        }
        return realm.getScriptLoader().evalScript(source, sourceCode, options);
    } catch (ParserException | CompilationException e) {
        throw e.toScriptException(cx);
    }
}
 

void parseRootLoggerElement(final XMLExtendedStreamReader reader, final PathAddress address, final List<ModelNode> operations) throws XMLStreamException {
    // No attributes
    if (reader.getAttributeCount() > 0) {
        throw unexpectedAttribute(reader, 0);
    }

    final ModelNode operation = Util.createAddOperation(address.append(RootLoggerResourceDefinition.NAME, RESOURCE_NAME));
    final EnumSet<Element> encountered = EnumSet.noneOf(Element.class);
    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        final Element element = Element.forName(reader.getLocalName());
        if (encountered.contains(element)) {
            throw duplicateNamedElement(reader, reader.getLocalName());
        }
        encountered.add(element);
        switch (element) {
            case FILTER: {
                parseFilter(operation, LoggerAttributes.FILTER_SPEC, reader);
                break;
            }
            case LEVEL: {
                LEVEL.parseAndSetParameter(readNameAttribute(reader), operation, reader);
                break;
            }
            case HANDLERS: {
                parseHandlersElement(element.getDefinition(), operation, reader);
                break;
            }
            default:
                throw unexpectedElement(reader);
        }
    }
    operations.add(operation);
}
 

private static TimelineEntity maskFields(
    TimelineEntity entity, EnumSet<Field> fields) {
  // Conceal the fields that are not going to be exposed
  TimelineEntity entityToReturn = new TimelineEntity();
  entityToReturn.setEntityId(entity.getEntityId());
  entityToReturn.setEntityType(entity.getEntityType());
  entityToReturn.setStartTime(entity.getStartTime());
  entityToReturn.setDomainId(entity.getDomainId());
  // Deep copy
  if (fields.contains(Field.EVENTS)) {
    entityToReturn.addEvents(entity.getEvents());
  } else if (fields.contains(Field.LAST_EVENT_ONLY)) {
    entityToReturn.addEvent(entity.getEvents().get(0));
  } else {
    entityToReturn.setEvents(null);
  }
  if (fields.contains(Field.RELATED_ENTITIES)) {
    entityToReturn.addRelatedEntities(entity.getRelatedEntities());
  } else {
    entityToReturn.setRelatedEntities(null);
  }
  if (fields.contains(Field.PRIMARY_FILTERS)) {
    entityToReturn.addPrimaryFilters(entity.getPrimaryFilters());
  } else {
    entityToReturn.setPrimaryFilters(null);
  }
  if (fields.contains(Field.OTHER_INFO)) {
    entityToReturn.addOtherInfo(entity.getOtherInfo());
  } else {
    entityToReturn.setOtherInfo(null);
  }
  return entityToReturn;
}
 

/**
 * Creates a JSON-like Watchman query to get a list of matching files.
 *
 * <p>The implementation should ideally match the one in glob_watchman.py.
 */
private ImmutableMap<String, ?> createWatchmanQuery(
    Collection<String> include, Collection<String> exclude, EnumSet<Option> options) {
  ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
  builder.putAll(
      ImmutableMap.of(
          "relative_root",
          basePath,
          "expression",
          toMatchExpressions(exclude, options),
          "glob",
          include,
          "fields",
          FIELDS_TO_INCLUDE));
  if (options.contains(Option.FORCE_CASE_SENSITIVE)) {
    builder.put("case_sensitive", true);
  }

  // Sync cookies cause a massive overhead when issuing thousands of
  // glob queries.  Only enable them (by not setting sync_timeout to 0)
  // for the very first request issued by this process.
  if (syncCookieState.shouldSyncCookies()) {
    syncCookieState.disableSyncCookies();
  } else {
    builder.put("sync_timeout", 0);
  }

  return builder.build();
}
 

public int getWeakPower(BlockFace side) {
    if (!this.canProvidePower) {
        return 0;
    } else {
        int power = this.meta;

        if (power == 0) {
            return 0;
        } else if (side == BlockFace.UP) {
            return power;
        } else {
            EnumSet<BlockFace> enumset = EnumSet.noneOf(BlockFace.class);

            for (BlockFace face : Plane.HORIZONTAL) {
                if (this.isPowerSourceAt(face)) {
                    enumset.add(face);
                }
            }

            if (side.getAxis().isHorizontal() && enumset.isEmpty()) {
                return power;
            } else if (enumset.contains(side) && !enumset.contains(side.rotateYCCW()) && !enumset.contains(side.rotateY())) {
                return power;
            } else {
                return 0;
            }
        }
    }
}
 

public MessageSievingInputStreamTest(EnumSet<TransformerOptions> options) throws Exception {
  this.options = options;
  this.storeKeyFactory = new MockIdFactory();
  this.randomKeyConverter = new RandomKeyConverter();
  if (options.contains(TransformerOptions.Validate)) {
    transformers.add(new ValidatingTransformer(storeKeyFactory, randomKeyConverter));
  }
  if (options.contains(TransformerOptions.KeyConvert)) {
    transformers.add(new ValidatingKeyConvertingTransformer(storeKeyFactory, randomKeyConverter));
  }
}
 

@Override
public ApplicationId
    submitApplication(ApplicationSubmissionContext appContext)
        throws YarnException, IOException {
  ApplicationId applicationId = appContext.getApplicationId();
  if (applicationId == null) {
    throw new ApplicationIdNotProvidedException(
        "ApplicationId is not provided in ApplicationSubmissionContext");
  }
  SubmitApplicationRequest request =
      Records.newRecord(SubmitApplicationRequest.class);
  request.setApplicationSubmissionContext(appContext);

  // Automatically add the timeline DT into the CLC
  // Only when the security and the timeline service are both enabled
  if (isSecurityEnabled() && timelineServiceEnabled) {
    addTimelineDelegationToken(appContext.getAMContainerSpec());
  }

  //TODO: YARN-1763:Handle RM failovers during the submitApplication call.
  rmClient.submitApplication(request);

  int pollCount = 0;
  long startTime = System.currentTimeMillis();
  EnumSet<YarnApplicationState> waitingStates = 
                               EnumSet.of(YarnApplicationState.NEW,
                               YarnApplicationState.NEW_SAVING,
                               YarnApplicationState.SUBMITTED);
  EnumSet<YarnApplicationState> failToSubmitStates = 
                                EnumSet.of(YarnApplicationState.FAILED,
                                YarnApplicationState.KILLED);		
  while (true) {
    try {
      ApplicationReport appReport = getApplicationReport(applicationId);
      YarnApplicationState state = appReport.getYarnApplicationState();
      if (!waitingStates.contains(state)) {
        if(failToSubmitStates.contains(state)) {
          throw new YarnException("Failed to submit " + applicationId + 
              " to YARN : " + appReport.getDiagnostics());
        }
        LOG.info("Submitted application " + applicationId);
        break;
      }

      long elapsedMillis = System.currentTimeMillis() - startTime;
      if (enforceAsyncAPITimeout() &&
          elapsedMillis >= asyncApiPollTimeoutMillis) {
        throw new YarnException("Timed out while waiting for application " +
            applicationId + " to be submitted successfully");
      }

      // Notify the client through the log every 10 poll, in case the client
      // is blocked here too long.
      if (++pollCount % 10 == 0) {
        LOG.info("Application submission is not finished, " +
            "submitted application " + applicationId +
            " is still in " + state);
      }
      try {
        Thread.sleep(submitPollIntervalMillis);
      } catch (InterruptedException ie) {
        LOG.error("Interrupted while waiting for application "
            + applicationId
            + " to be successfully submitted.");
      }
    } catch (ApplicationNotFoundException ex) {
      // FailOver or RM restart happens before RMStateStore saves
      // ApplicationState
      LOG.info("Re-submit application " + applicationId + "with the " +
          "same ApplicationSubmissionContext");
      rmClient.submitApplication(request);
    }
  }

  return applicationId;
}
 

/**
 * Function to draw the arrows on the attack/being attacked ring.
 *
 * @param g2d The graphic context
 * @param x The x-center of the arrows
 * @param y The y-center of the arrows
 * @param width ring width
 * @param height ring height
 * @param directions The directions an arrow should be drawn
 * @param lineColor The color of the outline of the arrow
 */
private void drawArrows(final Graphics2D g2d, final int x, final int y, final int width, final int height, final EnumSet<Direction> directions, final Color lineColor) {
	int arrowHeight = 6 + 2 * (height / 23 - 1);
	int arrowWidth = 3 + (width / 34 - 1);
	if (directions.contains(Direction.LEFT)) {
		g2d.setColor(Color.RED);
		g2d.fillPolygon(
				new int[] {x+1, x-arrowWidth, x+1},
				new int[]{y+(height/2)-(arrowHeight/2), y+(height/2),y+(height/2)+(arrowHeight/2)},
				3);
		g2d.setColor(lineColor);
		g2d.drawPolyline(
				new int[]{x, x-arrowWidth, x},
				new int[]{y+(height/2)-(arrowHeight/2), y+(height/2), y+(height/2)+(arrowHeight/2)},
				3);
	}
	if (directions.contains(Direction.RIGHT)) {
		g2d.setColor(Color.RED);
		g2d.fillPolygon(
				new int[]{x+width, x+width+arrowWidth, x+width},
				new int[]{y+(height/2)-(arrowHeight/2), y+(height/2), y+(height/2)+(arrowHeight/2)},
				3);
		g2d.setColor(lineColor);
		g2d.drawPolyline(
				new int[]{x+width, x+width+arrowWidth, x+width},
				new int[]{y+(height/2)-(arrowHeight/2), y+(height/2), y+(height/2)+(arrowHeight/2)},
				3);
	}
	if (directions.contains(Direction.UP)) {
		g2d.setColor(Color.RED);
		g2d.fillPolygon(
				new int[]{x+(width/2)-(arrowHeight/2), x+(width/2), x+(width/2)+(arrowHeight/2)},
				new int[]{y+1, y-arrowWidth, y+1},
				3);
		g2d.setColor(lineColor);
		g2d.drawPolyline(
				new int[]{x+(width/2)-(arrowHeight/2), x+(width/2), x+(width/2)+(arrowHeight/2)},
				new int[]{y, y-arrowWidth, y},
				3);
	}
	if (directions.contains(Direction.DOWN)) {
		g2d.setColor(Color.RED);
		g2d.fillPolygon(
				new int[]{x+(width/2)-(arrowHeight/2), x+(width/2), x+(width/2)+(arrowHeight/2)},
				new int[]{y+height, y+height+arrowWidth, y+height},
				3);
		g2d.setColor(lineColor);
		g2d.drawPolyline(
				new int[]{x+(width/2)-(arrowHeight/2), x+(width/2), x+(width/2)+(arrowHeight/2)},
				new int[]{y+height, y+height+arrowWidth, y+height},
				3);
	}
}
 

/**
 * Creates a new, empty map with the specified initial
 * capacity, reference types, load factor and concurrency level.
 * <p/>
 * Behavioral changing options such as {@link Option#IDENTITY_COMPARISONS}
 * can also be specified.
 *
 * @param initialCapacity the initial capacity. The implementation
 * performs internal sizing to accommodate this many elements.
 * @param loadFactor the load factor threshold, used to control resizing.
 * Resizing may be performed when the average number of elements per
 * bin exceeds this threshold.
 * @param concurrencyLevel the estimated number of concurrently
 * updating threads. The implementation performs internal sizing
 * to try to accommodate this many threads.
 * @param keyType the reference type to use for keys
 * @param valueType the reference type to use for values
 * @param options the behavioral options
 *
 * @throws IllegalArgumentException if the initial capacity is
 * negative or the load factor or concurrencyLevel are
 * nonpositive.
 */
public ConcurrentReferenceHashMap(
		int initialCapacity,
		float loadFactor, int concurrencyLevel,
		ReferenceType keyType, ReferenceType valueType,
		EnumSet<Option> options) {
	if ( !( loadFactor > 0 ) || initialCapacity < 0 || concurrencyLevel <= 0 ) {
		throw new IllegalArgumentException();
	}

	if ( concurrencyLevel > MAX_SEGMENTS ) {
		concurrencyLevel = MAX_SEGMENTS;
	}

	// Find power-of-two sizes best matching arguments
	int sshift = 0;
	int ssize = 1;
	while ( ssize < concurrencyLevel ) {
		++sshift;
		ssize <<= 1;
	}
	segmentShift = 32 - sshift;
	segmentMask = ssize - 1;
	this.segments = Segment.newArray( ssize );

	if ( initialCapacity > MAXIMUM_CAPACITY ) {
		initialCapacity = MAXIMUM_CAPACITY;
	}
	int c = initialCapacity / ssize;
	if ( c * ssize < initialCapacity ) {
		++c;
	}
	int cap = 1;
	while ( cap < c ) {
		cap <<= 1;
	}

	identityComparisons = options != null && options.contains( Option.IDENTITY_COMPARISONS );

	for ( int i = 0; i < this.segments.length; ++i ) {
		this.segments[i] = new Segment<K, V>(
				cap, loadFactor,
				keyType, valueType, identityComparisons
		);
	}
}
 

ModelNode parsePolicyElement(XMLExtendedStreamReader reader, final ModelNode address, final List<ModelNode> list) throws XMLStreamException {
    final ModelNode policy = new ModelNode();
    policy.get(OP).set(ADD);
    policy.get(OP_ADDR).set(address).add(SaslPolicyResource.SASL_POLICY_CONFIG_PATH.getKey(), SaslPolicyResource.SASL_POLICY_CONFIG_PATH.getValue());
    list.add(policy);

    if (reader.getAttributeCount() > 0) {
        throw ParseUtils.unexpectedAttribute(reader, 0);
    }
    // Handle nested elements.
    final EnumSet<Element> visited = EnumSet.noneOf(Element.class);
    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        final Element element = Element.forName(reader.getLocalName());
        if (visited.contains(element)) {
            throw ParseUtils.unexpectedElement(reader);
        }
        visited.add(element);
        switch (element) {
            case FORWARD_SECRECY: {
                SaslPolicyResource.FORWARD_SECRECY.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            case NO_ACTIVE: {
                SaslPolicyResource.NO_ACTIVE.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            case NO_ANONYMOUS: {
                SaslPolicyResource.NO_ANONYMOUS.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            case NO_DICTIONARY: {
                SaslPolicyResource.NO_DICTIONARY.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            case NO_PLAIN_TEXT: {
                SaslPolicyResource.NO_PLAIN_TEXT.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            case PASS_CREDENTIALS: {
                SaslPolicyResource.PASS_CREDENTIALS.parseAndSetParameter(readStringAttributeElement(reader, "value"), policy, reader);
                break;
            }
            default: {
                throw unexpectedElement(reader);
            }
        }
    }
    return policy;
}
 

@Override
public FSDataOutputStream create(Path f, EnumSet<CreateFlag> createFlag,
    CreateOpts... opts) throws AccessControlException,
    FileAlreadyExistsException, FileNotFoundException,
    ParentNotDirectoryException, UnsupportedFileSystemException, IOException {

  // Need to translate the FileContext-style options into FileSystem-style

  // Permissions with umask
  CreateOpts.Perms permOpt = CreateOpts.getOpt(
      CreateOpts.Perms.class, opts);
  FsPermission umask = FsPermission.getUMask(fs.getConf());
  FsPermission permission = (permOpt != null) ? permOpt.getValue()
      : FsPermission.getFileDefault().applyUMask(umask);
  permission = permission.applyUMask(umask);
  // Overwrite
  boolean overwrite = createFlag.contains(CreateFlag.OVERWRITE);
  // bufferSize
  int bufferSize = fs.getConf().getInt(
      CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_KEY,
      CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_DEFAULT);
  CreateOpts.BufferSize bufOpt = CreateOpts.getOpt(
      CreateOpts.BufferSize.class, opts);
  bufferSize = (bufOpt != null) ? bufOpt.getValue() : bufferSize;
  // replication
  short replication = fs.getDefaultReplication(f);
  CreateOpts.ReplicationFactor repOpt =
      CreateOpts.getOpt(CreateOpts.ReplicationFactor.class, opts);
  replication = (repOpt != null) ? repOpt.getValue() : replication;
  // blockSize
  long blockSize = fs.getDefaultBlockSize(f);
  CreateOpts.BlockSize blockOpt = CreateOpts.getOpt(
      CreateOpts.BlockSize.class, opts);
  blockSize = (blockOpt != null) ? blockOpt.getValue() : blockSize;
  // Progressable
  Progressable progress = null;
  CreateOpts.Progress progressOpt = CreateOpts.getOpt(
      CreateOpts.Progress.class, opts);
  progress = (progressOpt != null) ? progressOpt.getValue() : progress;
  return fs.create(f, permission, overwrite, bufferSize, replication,
      blockSize, progress);
}
 

private void copy(RemoteFile srf, RemoteFile drf, EnumSet<Mode> mode, boolean jobSucceeded) throws Exception {

        String srcScheme = defaultToLocal(srf.getProtocol());
        String dstScheme = defaultToLocal(drf.getProtocol());

        Service ss = new ServiceImpl(srcScheme, getServiceContact(srf), null);
        Service ds = new ServiceImpl(dstScheme, getServiceContact(drf), null);
        
        FileResource sres = FileResourceCache.getDefault().getResource(ss);
        FileResource dres = FileResourceCache.getDefault().getResource(ds);
                
        String srcPath = getPath(srf);
        
        boolean delete = false;
        if (mode.contains(Mode.IF_PRESENT) && !sres.exists(srcPath)) {
            delete = true;
        }
        if (mode.contains(Mode.ON_SUCCESS) && !jobSucceeded) {
            delete = true;
        }
        if (mode.contains(Mode.ON_ERROR) && jobSucceeded) {
            delete = true;
        }
        
        String dstPath = getPath(drf);
        if (delete) {
            if (dres.exists(dstPath)) {
                dres.deleteFile(dstPath);
            }
            return;
        }
        
        InputStream is = sres.openInputStream(srcPath);
        OutputStream os = dres.openOutputStream(dstPath);
        byte[] buffer = new byte[BUFFER_SIZE];

        int len = is.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = is.read(buffer);
        }
        os.close();
        is.close();
        
        FileResourceCache.getDefault().releaseResource(sres);
        FileResourceCache.getDefault().releaseResource(dres);
    }
 

/**
 * Returns true if a given feature is supported in the given layout version
 * @param f Feature
 * @param lv LayoutVersion
 * @return true if {@code f} is supported in layout version {@code lv}
 */
public static boolean supports(final Feature f, final int lv) {
  final EnumSet<Feature> set =  map.get(lv);
  return set != null && set.contains(f);
}