Java Code Examples for com.google.common.primitives.Ints#checkedCast()

@Inject
public CassandraAccessTokenDAO(Session session, @Named(TOKEN_EXPIRATION_IN_MS) long durationInMilliseconds) {
    this.cassandraAsyncExecutor = new CassandraAsyncExecutor(session);
    this.durationInSeconds = Ints.checkedCast(TimeUnit.MILLISECONDS.toSeconds(durationInMilliseconds));

    this.removeStatement = session.prepare(delete()
        .from(CassandraAccessTokenTable.TABLE_NAME)
        .where(eq(CassandraAccessTokenTable.TOKEN, bindMarker(CassandraAccessTokenTable.TOKEN))));

    this.insertStatement = session.prepare(insertInto(CassandraAccessTokenTable.TABLE_NAME)
        .value(CassandraAccessTokenTable.TOKEN, bindMarker(CassandraAccessTokenTable.TOKEN))
        .value(CassandraAccessTokenTable.USERNAME, bindMarker(CassandraAccessTokenTable.USERNAME))
        .using(ttl(bindMarker(TTL))));

    this.selectStatement = session.prepare(select()
        .from(CassandraAccessTokenTable.TABLE_NAME)
        .where(eq(CassandraAccessTokenTable.TOKEN, bindMarker(CassandraAccessTokenTable.TOKEN))));
}
 

SegmentNonMemoryPool(OffHeapHashTableBuilder<V> builder) {
    super(builder.getValueSerializer(), builder.getFixedValueSize(), builder.getHasher());

    this.hashAlgorithm = builder.getHashAlgorighm();

    int hts = builder.getHashTableSize();
    if (hts <= 0) {
        hts = 8192;
    }
    if (hts < 256) {
        hts = 256;
    }
    int msz = Ints.checkedCast(HashTableUtil.roundUpToPowerOf2(hts, MAX_TABLE_SIZE));
    table = Table.create(msz, throwOOME);
    if (table == null) {
        throw new RuntimeException("unable to allocate off-heap memory for segment");
    }

    float lf = builder.getLoadFactor();
    if (lf <= .0d) {
        lf = .75f;
    }
    this.loadFactor = lf;
    threshold = (long) ((double) table.size() * loadFactor);
}
 

public static int numberToInt(Number n) {
	if (n instanceof Integer) {
		return (Integer) n;
	} else if (n instanceof Long) {
		return Ints.checkedCast((Long) n);
	} else {
		throw new IllegalStateException("Length should be int or long");
	}
}
 

/**
 * Class constructor.
 *
 * @param factory a factory for TCP sockets
 * @param updateHost host name of the DNS server
 * @param updateTimeout update I/O timeout
 */
@Inject
public DnsMessageTransport(
    SocketFactory factory,
    @Config("dnsUpdateHost") String updateHost,
    @Config("dnsUpdateTimeout") Duration updateTimeout) {
  this.factory = factory;
  this.updateHost = updateHost;
  this.updateTimeout = Ints.checkedCast(updateTimeout.getMillis());
}
 

/**
 * normalize object for future sent in Salesforce
 *
 * @param valueMeta value meta
 * @param value pentaho internal value object
 * @return object for sending in Salesforce
 * @throws KettleValueException
 */
public Object normalizeValue( ValueMetaInterface valueMeta, Object value ) throws KettleValueException {
  if ( valueMeta.isDate() ) {
    // Pass date field converted to UTC, see PDI-10836
    Calendar cal = Calendar.getInstance( valueMeta.getDateFormatTimeZone() );
    cal.setTime( valueMeta.getDate( value ) );
    Calendar utc = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
    // Reset time-related fields
    utc.clear();
    utc.set( cal.get( Calendar.YEAR ), cal.get( Calendar.MONTH ), cal.get( Calendar.DATE ),
      cal.get( Calendar.HOUR_OF_DAY ), cal.get( Calendar.MINUTE ), cal.get( Calendar.SECOND ) );
    value = utc;
  } else if ( valueMeta.isStorageBinaryString() ) {
    value = valueMeta.convertToNormalStorageType( value );
  }

  if ( ValueMetaInterface.TYPE_INTEGER == valueMeta.getType() ) {
    // Salesforce integer values can be only http://www.w3.org/2001/XMLSchema:int
    // see org.pentaho.di.ui.trans.steps.salesforceinput.SalesforceInputDialog#addFieldToTable
    // So we need convert Hitachi Vantara integer (real java Long value) to real int.
    // It will be sent correct as http://www.w3.org/2001/XMLSchema:int

    // use checked cast for prevent losing data
    value = Ints.checkedCast( (Long) value );
  }
  return value;
}
 

@Override
public Closeable acquirePermits(long permits)
    throws InterruptedException {
  int permitsToAcquire = Ints.checkedCast(permits);
  this.permitPool.acquire(permitsToAcquire);
  return new PoolPermitCloseable(this.permitPool, permitsToAcquire);
}
 

/**
 * Converts an object Long to a primitive int.
 *
 * @param value the <tt>Long</tt> value
 * @return <tt>0</tt> if the given Long value is null else <tt>integer value</tt>
 */
public static int toPrimitiveInt(Long value) {
    if (value == null) {
        return 0;
    }
    // throws IllegalArgumentException - if value is greater than Integer.MAX_VALUE
    // or less than Integer.MIN_VALUE
    return Ints.checkedCast(value);
}
 

/**
 * recalculate interval(in hours) if total number of partitions greater than maximum number of allowed partitions
 *
 * @param diffInMilliSecs difference in range
 * @param hourInterval hour interval (ex: 4 hours)
 * @param maxIntervals max number of allowed partitions
 * @return calculated interval in hours
 */

private static int getInterval(long diffInMilliSecs, long hourInterval, int maxIntervals) {

  long totalHours = DoubleMath.roundToInt((double) diffInMilliSecs / (60 * 60 * 1000), RoundingMode.CEILING);
  long totalIntervals = DoubleMath.roundToInt((double) totalHours / hourInterval, RoundingMode.CEILING);
  if (totalIntervals > maxIntervals) {
    hourInterval = DoubleMath.roundToInt((double) totalHours / maxIntervals, RoundingMode.CEILING);
  }
  return Ints.checkedCast(hourInterval);
}
 

@Override
public void truncate(long size) throws IOException {
  ensureNotClosed();
  int intSize = Ints.checkedCast(size);
  byte[] bytes = stream.toByteArray();
  stream = new ByteArrayOutputStream(intSize);
  stream.write(bytes, 0, intSize);
}
 

long getElement(long idx) {
    long elt = 0;
    long bitpos = ELEMENT_BITS * idx;
    int tabpos = Ints.checkedCast(bitpos / 64);
    long slotpos = bitpos % 64;
    long spillbits = (slotpos + ELEMENT_BITS) - 64;
    elt = (table[tabpos] >>> slotpos) & ELEMENT_MASK;
    if (spillbits > 0) {
        ++tabpos;
        long x = table[tabpos] & LOW_MASK(spillbits);
        elt |= x << (ELEMENT_BITS - spillbits);
    }
    return elt;
}
 

@Override
// @IgnoreJRERequirement
public TftpData open(String filename) throws IOException {
    File file = toFile(filename);
    if (file == null)
        return null;
    RandomAccessFile raf = new RandomAccessFile(file, "r");
    FileChannel channel = raf.getChannel();
    // FileChannel channel = FileChannel.open(file.toPath(), StandardOpenOption.READ);
    return new TftpFileChannelData(channel, Ints.checkedCast(channel.size()));
}
 

static int TABLE_SIZE(int quotientBits, int remainderBits) {
    long bits = (1L << quotientBits) * (remainderBits + 3);
    long longs = bits / 64;
    return Ints.checkedCast((bits % 64) > 0 ? (longs + 1) : longs);
}
 

@Override
public int getTwoWindingsTransformerCount() {
    return Ints.checkedCast(getTwoWindingsTransformerStream()
            .count());
}
 

@Override
public <C extends Connectable> int getConnectableCount(Class<C> clazz) {
    return Ints.checkedCast(getConnectableStream(clazz).count());
}
 

BitArray(long bits) {
  this(
    new long[Ints.checkedCast(LongMath.divide(bits, 64, RoundingMode.CEILING))]);
}
 

BitArray(long bits) {
    this(new long[Ints.checkedCast(LongMath.divide(bits, 64, RoundingMode.CEILING))]);
}
 

@Override
public void waitUntilReady(WaitStrategyTarget waitStrategyTarget) {
    int seconds = Ints.checkedCast(this.timeout.getSeconds());

    Unreliables.retryUntilTrue(seconds, TimeUnit.SECONDS, this::isConnected);
}
 

private XdsStatsWatcher(long startId, long endId) {
  latch = new CountDownLatch(Ints.checkedCast(endId - startId));
  this.startId = startId;
  this.endId = endId;
}
 

/**
 * Get the message length from a {@link ByteBuf} containing a {@link TcpMessageEncoder}. The reader index will not be
 * advanced.
 *
 * @param buffer {@link ByteBuf} to extract from.
 * @return The message length, which includes the size of the header.
 */
default int getMessageLength(ByteBuf buffer) {
    return Ints.checkedCast(buffer.getUnsignedInt(buffer.readerIndex() + HEADER_LENGTH_INDEX));
}
 

/**
 * Get the Slot index.
 *
 * @return      The index of this slot.
 */
public int getSlotIdx() {
  return Ints.checkedCast(
      (slotAddress - baseAddress) / BYTES_PER_SLOT);
}