Builds RocksDb {@link ReadOptions}.

@param isTailing
@return
962252
public static ReadOptions buildReadOptions(boolean isTailing) {
        ReadOptions readOptions = new ReadOptions();
        readOptions.setTailing(isTailing);
        return readOptions;
    }
937962
public PackageDescr read(final InputSource in) throws SAXException,
                                                  IOException {
        this.packageDescr = (PackageDescr) this.parser.read( in );
        return this.packageDescr;
    }
1026203
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
  public final <T> S withOption(CallOptions.Key<T> key, T value) {
    return build(channel, callOptions.withOption(key, value));
  }
404363
static Cl map(ResultSet rs, int colShift)
    {
        Cl tmp = new Cl();

        try
        {
            tmp.id = rs.getInt(1 + colShift);
            tmp.name = rs.getString(2 + colShift);
            tmp.childFirst = rs.getBoolean(3 + colShift);
            tmp.hiddenClasses = rs.getString(4 + colShift);
            tmp.tracingEnabled = rs.getBoolean(5 + colShift);
            tmp.persistent = rs.getBoolean(6 + colShift);
            tmp.allowedRunners = rs.getString(7 + colShift);
        }
        catch (SQLException e)
        {
            throw new DatabaseException(e);
        }
        return tmp;
    }
1283624
private ServiceElement readService(Location location, String documentation) {
    String name = reader.readName();

    reader.require('{');
    ImmutableList.Builder<RpcElement> rpcs = ImmutableList.builder();
    ImmutableList.Builder<OptionElement> options = ImmutableList.builder();
    while (true) {
      String rpcDocumentation = reader.readDocumentation();
      if (reader.peekChar('}')) break;

      Object declared = readDeclaration(rpcDocumentation, Context.SERVICE);
      if (declared instanceof RpcElement) {
        rpcs.add((RpcElement) declared);
      } else if (declared instanceof OptionElement) {
        options.add((OptionElement) declared);
      }
    }
    return new ServiceElement(
        location,
        name,
        documentation,
        rpcs.build(),
        options.build()
    );
  }
1142795
public static InputStreamResource buildInputStreamResourceFrom(final String value, final String description) {
        val reader = new StringReader(value);
        val is = new ReaderInputStream(reader, StandardCharsets.UTF_8);
        return new InputStreamResource(is, description);
    }
722008
public static RocksDbWrapper openReadOnly(File directory, DBOptions dbOptions,
            ReadOptions readOptions) throws RocksDbException, IOException {
        RocksDbWrapper rocksDbWrapper = new RocksDbWrapper(directory, true);
        rocksDbWrapper.setDbOptions(dbOptions).setReadOptions(readOptions);
        rocksDbWrapper.init();
        return rocksDbWrapper;
    }
266977
function IteratorOptions(options) {
  this.keys = true;
  this.values = true;
  this.start = null;
  this.end = null;
  this.gt = false;
  this.lt = false;
  this.keyAsBuffer = true;
  this.valueAsBuffer = true;
  this.reverse = false;
  this.limit = -1;

  if (options)
    this.fromOptions(options);
}
1066841
public LogPublishingOptionsStatus withOptions(java.util.Map<String, LogPublishingOption> options) {
        setOptions(options);
        return this;
    }
1185235
public static MutableFst readFstFromBinaryStream(ObjectInput in) throws IOException,
                                                                          ClassNotFoundException {
    int version = in.readInt();
    if (version < FIRST_VERSION && version > CURRENT_VERSION) {
      throw new IllegalArgumentException("cant read version fst model " + version);
    }

    MutableSymbolTable is = readStringMap(in);
    MutableSymbolTable os = readStringMap(in);

    MutableSymbolTable ss = null;
    if (in.readBoolean()) {
      ss = readStringMap(in);
    }
    return readFstWithTables(in, is, os, ss);
  }
962489
private IAtomContainer readCoordinates(IAtomContainer molecule, boolean coordinatesUnits) throws IOException {

        /*
         * Coordinates must all be given in angstr???ms.
         */
        double unitScaling = GamessReader.scalesCoordinatesUnits(coordinatesUnits);

        String retrievedLineFromFile;

        while (this.input.ready() == true) {
            retrievedLineFromFile = this.input.readLine();
            /*
             * A coordinate set is followed by an empty line, so when this line
             * is reached, there are no more coordinates to add to the current
             * set.
             */
            if ((retrievedLineFromFile == null) || (retrievedLineFromFile.trim().length() == 0)) {
                break;
            }

            int atomicNumber;
            String atomicSymbol;

            //StringReader sr = new StringReader(retrievedLineFromFile);
            StreamTokenizer token = new StreamTokenizer(new StringReader(retrievedLineFromFile));

            /*
             * The first token is ignored. It contains the atomic symbol and may
             * be concatenated with a number.
             */
            token.nextToken();

            if (token.nextToken() == StreamTokenizer.TT_NUMBER) {
                atomicNumber = (int) token.nval;
                atomicSymbol = this.identifyAtomicSymbol(atomicNumber);
                /*
                 * Dummy atoms are assumed to be given with an atomic number set
                 * to zero. We will do not add them to the molecule.
                 */
                if (atomicNumber == 0) {
                    continue;
                }
            } else {
                throw new IOException("Error reading coordinates");
            }

            /*
             * Atom's coordinates are stored in an array.
             */
            double[] coordinates = new double[3];
            for (int i = 0; i < coordinates.length; i++) {
                if (token.nextToken() == StreamTokenizer.TT_NUMBER) {
                    coordinates[i] = token.nval * unitScaling;
                } else {
                    throw new IOException("Error reading coordinates");
                }
            }
            IAtom atom = molecule.getBuilder().newInstance(IAtom.class, atomicSymbol,
                    new Point3d(coordinates[0], coordinates[1], coordinates[2]));
            molecule.addAtom(atom);
        }
        return molecule;
    }
144358
public void put(WriteOptions writeOptions, String key, byte[] value) throws RocksDbException {
        put(DEFAULT_COLUMN_FAMILY, writeOptions, key, value);
    }
423268
public AccessLogOption prepareAccessLogOption(BootLogger logger, Properties props, List<String> readConfigList) { // null allowed
        if (props == null) {
            return null;
        }
        final String enabled = props.getProperty("tomcat.accesslog.enabled");
        if (enabled == null || !isStringBooleanTrue(enabled)) {
            return null;
        }
        logger.info("...Preparing tomcat access log: enabled=" + enabled + ", config=" + readConfigList);
        final AccessLogOption option = new AccessLogOption();
        doPrepareAccessLogOption(logger, props, "logDir", value -> option.logDir(value));
        doPrepareAccessLogOption(logger, props, "filePrefix", value -> option.filePrefix(value));
        doPrepareAccessLogOption(logger, props, "fileSuffix", value -> option.fileSuffix(value));
        doPrepareAccessLogOption(logger, props, "fileDateFormat", value -> option.fileDateFormat(value));
        doPrepareAccessLogOption(logger, props, "fileEncoding", value -> option.fileEncoding(value));
        doPrepareAccessLogOption(logger, props, "formatPattern", value -> option.formatPattern(value));
        doPrepareAccessLogOption(logger, props, "conditionIf", value -> option.conditionIf(value));
        doPrepareAccessLogOption(logger, props, "conditionUnless", value -> option.conditionUnless(value));
        return option;
    }
1006179
public List<AbstractCounterConfiguration> parseConfigurations(InputStream is) throws XMLStreamException {
      BufferedInputStream input = new BufferedInputStream(is);
      XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(input);
      CounterManagerConfigurationBuilder builder = new CounterManagerConfigurationBuilder(null);
      try {
         reader.require(START_DOCUMENT, null, null);
         reader.nextTag();
         reader.require(START_ELEMENT, null, null);
         Element element = Element.forName(reader.getLocalName());
         switch (element) {
            case COUNTERS: {
               parseCountersElement(reader, builder);
               break;
            }
            default: {
               throw ParseUtils.unexpectedElement(reader);
            }
         }
      } finally {
         reader.close();
      }
      return builder.create().counters();
   }
942624
private static Options constructOptions() {
    Options options = new Options();

    Option topName = Option.builder("t")
        .desc("Name of the topology")
        .longOpt("topologyname")
        .hasArgs()
        .argName("topologyname")
        .required()
        .build();

    Option topId = Option.builder("i")
        .desc("Id of the topology")
        .longOpt("topologyid")
        .hasArgs()
        .argName("topologyid")
        .required()
        .build();

    Option ckptMgrId = Option.builder("c")
        .desc("Id of the checkpoint manager")
        .longOpt("ckptmgrid")
        .hasArgs()
        .argName("ckptmgrid")
        .required()
        .build();

    Option ckptMgrPort = Option.builder("p")
        .desc("Port of the checkpoint manager")
        .longOpt("ckptmgrport")
        .hasArgs()
        .argName("ckptmgrport")
        .required()
        .build();

    Option ckptMgrConfig = Option.builder("f")
        .desc("Config name of the checkpoint manager")
        .longOpt("ckptmgrconfig")
        .hasArgs()
        .argName("ckptmgrconfig")
        .required()
        .build();

    Option ckptMgrOverridenConfig = Option.builder("o")
        .desc("Config name of the checkpoint manager")
        .longOpt("ckptMgrOverridenConfig")
        .hasArgs()
        .argName("ckptMgrOverridenConfig")
        .build();

    Option heronInternalConfig = Option.builder("g")
        .desc("Heron internal config filename")
        .longOpt("heroninternalconfig")
        .hasArgs()
        .argName("heroninternalconfig")
        .required()
        .build();

    options.addOption(topName);
    options.addOption(topId);
    options.addOption(ckptMgrId);
    options.addOption(ckptMgrPort);
    options.addOption(ckptMgrConfig);
    options.addOption(ckptMgrOverridenConfig);
    options.addOption(heronInternalConfig);

    return options;
  }
1361796
private ModelNode readEndpointConfiguration() {
        ModelNode op = new ModelNode();
        op.get(ADDRESS).set(ENDPOINT_CONFIGURATION_ADDRESS.resolve(statementContext));
        op.get(OP).set(READ_RESOURCE_OPERATION);
        op.get(INCLUDE_RUNTIME).set(true);
        op.get(RECURSIVE).set(true);
        return op;
    }
593905
public static ImmutableSet<OpenOption> getOptionsForChannel(Set<? extends OpenOption> options) {
    if (options.isEmpty()) {
      return DEFAULT_READ;
    }

    boolean append = options.contains(APPEND);
    boolean write = append || options.contains(WRITE);
    boolean read = !write || options.contains(READ);

    if (read) {
      if (append) {
        throw new UnsupportedOperationException("'READ' + 'APPEND' not allowed");
      }

      if (!write) {
        // ignore all write related options
        return options.contains(LinkOption.NOFOLLOW_LINKS)
            ? DEFAULT_READ_NOFOLLOW_LINKS
            : DEFAULT_READ;
      }
    }

    // options contains write or append and may also contain read
    // it does not contain both read and append
    return addWrite(options);
  }