org.springframework.data.redis.connection.convert.Converters.stringToBooleanConverter java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 FileOutputStream f =File file;new FileOutputStream(file)
String name;new FileOutputStream(name)
File file;new FileOutputStream(file, true)
Smart code suggestions by Tabnine
}

public static Boolean stringToBoolean(String s) {
  return stringToBooleanConverter().convert(s);
}

@Override
public Boolean set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().set(key, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newJedisResult(connection.getRequiredTransaction().set(key, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().set(key, value));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Boolean setEx(byte[] key, long seconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  if (seconds > Integer.MAX_VALUE) {
    throw new IllegalArgumentException("Time must be less than Integer.MAX_VALUE for setEx in Jedis.");
  }
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().setex(key, (int) seconds, value),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newJedisResult(connection.getRequiredTransaction().setex(key, (int) seconds, value),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().setex(key, (int) seconds, value));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Boolean setEx(byte[] key, long seconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(getAsyncConnection().setex(key, seconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newLettuceResult(getAsyncConnection().setex(key, seconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().setex(key, seconds, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean pSetEx(byte[] key, long milliseconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(getAsyncConnection().psetex(key, milliseconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newLettuceResult(getAsyncConnection().psetex(key, milliseconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().psetex(key, milliseconds, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().set(key, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean pSetEx(byte[] key, long milliseconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().psetex(key, milliseconds, value),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newJedisResult(connection.getRequiredTransaction().psetex(key, milliseconds, value),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().psetex(key, milliseconds, value));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Boolean set(byte[] key, byte[] value, Expiration expiration, SetOption option) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  Assert.notNull(expiration, "Expiration must not be null!");
  Assert.notNull(option, "Option must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(
          getAsyncConnection().set(key, value, LettuceConverters.toSetArgs(expiration, option)),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newLettuceResult(
          getAsyncConnection().set(key, value, LettuceConverters.toSetArgs(expiration, option)),
          Converters.stringToBooleanConverter(), () -> false));
      return null;
    }
    return Converters
        .stringToBoolean(getConnection().set(key, value, LettuceConverters.toSetArgs(expiration, option)));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(getAsyncConnection().mset(tuples), Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newLettuceResult(getAsyncConnection().mset(tuples), Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().mset(tuples));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().mset(JedisConverters.toByteArrays(tuples)),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newJedisResult(connection.getRequiredTransaction().mset(JedisConverters.toByteArrays(tuples)),
              Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().mset(JedisConverters.toByteArrays(tuples)));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

    Converters.stringToBooleanConverter(), () -> false));
return null;
    Converters.stringToBooleanConverter(), () -> false));
return null;
    Converters.stringToBooleanConverter(), () -> false));
return null;
    Converters.stringToBooleanConverter(), () -> false));
return null;

public static Boolean stringToBoolean(String s) {
  return stringToBooleanConverter().convert(s);
}

public static Boolean stringToBoolean(String s) {
  return stringToBooleanConverter().convert(s);
}

@Override
public Boolean set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().set(key, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newJedisResult(connection.getRequiredTransaction().set(key, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().set(key, value));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Boolean setEx(byte[] key, long seconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(getAsyncConnection().setex(key, seconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(connection.newLettuceResult(getAsyncConnection().setex(key, seconds, value),
          Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().setex(key, seconds, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().set(key, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    if (isPipelined()) {
      pipeline(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().set(key, value));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newLettuceResult(getAsyncConnection().mset(tuples), Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newLettuceResult(getAsyncConnection().mset(tuples), Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(getConnection().mset(tuples));
  } catch (Exception ex) {
    throw convertLettuceAccessException(ex);
  }
}

@Override
public Boolean mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().mset(JedisConverters.toByteArrays(tuples)),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newJedisResult(connection.getRequiredTransaction().mset(JedisConverters.toByteArrays(tuples)),
              Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().mset(JedisConverters.toByteArrays(tuples)));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Boolean mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  try {
    if (isPipelined()) {
      pipeline(connection.newJedisResult(connection.getRequiredPipeline().mset(JedisConverters.toByteArrays(tuples)),
          Converters.stringToBooleanConverter()));
      return null;
    }
    if (isQueueing()) {
      transaction(
          connection.newJedisResult(connection.getRequiredTransaction().mset(JedisConverters.toByteArrays(tuples)),
              Converters.stringToBooleanConverter()));
      return null;
    }
    return Converters.stringToBoolean(connection.getJedis().mset(JedisConverters.toByteArrays(tuples)));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

Popular methods of Converters

toProperties
deserializingGeoResultsConverter
Converter capable of deserializing GeoResults.
listToPropertiesConverter
Returns a converter to convert array outputs with key-value sequences (such as produced by CONFIG GE
mapToPropertiesConverter
Returns a converter to convert from Map to Properties.
millisecondsToTimeUnit
Creates a new Converter to convert from milliseconds to the given TimeUnit.
secondsToDuration
Convert the given nullable seconds to a Duration or null.
secondsToTimeUnit
Creates a new Converter to convert from seconds to the given TimeUnit.
stringToBoolean
toClusterNode
Converts the result of a single line of CLUSTER NODES into a RedisClusterNode.
toSetOfRedisClusterNodes
Converts lines from the result of CLUSTER NODES into RedisClusterNodes.
toTimeMillis
Returns the timestamp constructed from the given seconds and microseconds.

toTimeMillis

Popular in Java

Running tasks concurrently on multiple threads
startActivity (Activity)
compareTo (BigDecimal)
requestLocationUpdates (LocationManager)
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no
JFrame (javax.swing)
21 Best Atom Packages for 2021

How to use stringToBooleanConvertermethodin org.springframework.data.redis.connection.convert.Converters

Best Java code snippets using org.springframework.data.redis.connection.convert.Converters.stringToBooleanConverter (Showing top 20 results out of 315)

How to use
stringToBooleanConverter
method
in
org.springframework.data.redis.connection.convert.Converters