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

@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("Seconds have cannot exceed Integer.MAX_VALUE!");
  }
  try {
    return Converters.stringToBoolean(connection.getCluster().setex(key, Long.valueOf(seconds).intValue(), value));
  } catch (Exception ex) {
    throw convertJedisAccessException(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.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 set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    return Converters.stringToBoolean(connection.getCluster().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 mSet(Map<byte[], byte[]> tuples) {
  Assert.notNull(tuples, "Tuples must not be null!");
  if (ClusterSlotHashUtil.isSameSlotForAllKeys(tuples.keySet().toArray(new byte[tuples.keySet().size()][]))) {
    try {
      return Converters.stringToBoolean(connection.getCluster().mset(JedisConverters.toByteArrays(tuples)));
    } catch (Exception ex) {
      throw convertJedisAccessException(ex);
    }
  }
  boolean result = true;
  for (Map.Entry<byte[], byte[]> entry : tuples.entrySet()) {
    if (!set(entry.getKey(), entry.getValue())) {
      result = false;
    }
  }
  return result;
}

@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 pSetEx(byte[] key, long milliseconds, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  return Converters.stringToBoolean(connection.getClusterCommandExecutor()
      .executeCommandOnSingleNode(
          (JedisClusterCommandCallback<String>) client -> client.psetex(key, milliseconds, value),
          connection.getTopologyProvider().getTopology().getKeyServingMasterNode(key))
      .getValue());
}

@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);
  }
}

  return Converters.stringToBoolean(connection.getCluster().set(key, value, params));
} catch (Exception ex) {
  throw convertJedisAccessException(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 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("Seconds have cannot exceed Integer.MAX_VALUE!");
  }
  try {
    return Converters.stringToBoolean(connection.getCluster().setex(key, Long.valueOf(seconds).intValue(), value));
  } 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.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 set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    return Converters.stringToBoolean(connection.getCluster().set(key, 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 set(byte[] key, byte[] value) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(value, "Value must not be null!");
  try {
    return Converters.stringToBoolean(connection.getCluster().set(key, value));
  } 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);
  }
}

@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!");
  return Converters.stringToBoolean(connection.getClusterCommandExecutor()
      .executeCommandOnSingleNode(
          (JedisClusterCommandCallback<String>) client -> client.psetex(key, milliseconds, value),
          connection.getTopologyProvider().getTopology().getKeyServingMasterNode(key))
      .getValue());
}

  return Converters.stringToBoolean(connection.getJedis().set(key, value, nxxx));
} catch (Exception ex) {
  throw convertJedisAccessException(ex);
  return Converters.stringToBoolean(connection.getJedis().set(key, value, params));

@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!");
  return Converters.stringToBoolean(connection.getClusterCommandExecutor()
      .executeCommandOnSingleNode(
          (JedisClusterCommandCallback<String>) client -> client.psetex(key, milliseconds, value),
          connection.getTopologyProvider().getTopology().getKeyServingMasterNode(key))
      .getValue());
}

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.
stringToBooleanConverter
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

Start an intent from android
requestLocationUpdates (LocationManager)
getContentResolver (Context)
setRequestProperty (URLConnection)
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
InputStream (java.io)
A readable source of bytes.Most clients will use input streams that read data from the file system (
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
InetAddress (java.net)
An Internet Protocol (IP) address. This can be either an IPv4 address or an IPv6 address, and in pra
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
Table (org.hibernate.mapping)
A relational table
Top plugins for WebStorm

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

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

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