signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # ttl ( java . lang . Object , java . lang . Object ) */
public Long ttl ( HK key , HV value ) { } }

implementation: return ops . ttl ( getKey ( ) , getField ( ) , key , value ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # get ( java . lang . Object , java . lang . Object , java . lang . Object ) */
public List < HV > get ( H key , HK field , HK name ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] rawElementName = rawHashKey ( name ) ; List < byte [ ] > rawElementValues = execute ( new RedisCallback < List < byte [ ] > > ( ) { public List < byte [ ] > doInRedis ( RedisConnection connection ) { return ( ( RedisClusterConnection ) connection ) . slGet ( rawKey , rawHashKey , rawElementName ) ; } } , true ) ; return deserializeHashValues ( rawElementValues ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # multiGet ( java . lang . Object , java . lang . Object , java . util . Collection ) */
public Map < HK , List < HV > > multiGet ( H key , HK field , Collection < HK > names ) { } }

implementation: if ( names . isEmpty ( ) ) { return new HashMap < HK , List < HV > > ( ) ; } final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] [ ] rawElementNames = new byte [ names . size ( ) ] [ ] ; int count = 0 ; for ( HK name : names ) { rawElementNames [ count ++ ] = rawHashKey ( name ) ; } Map < byte [ ] , List < byte [ ] > > rawElementValues = execute ( new RedisCallback < Map < byte [ ] , List < byte [ ] > > > ( ) { public Map < byte [ ] , List < byte [ ] > > doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . slMGet ( rawKey , rawHashKey , rawElementNames ) ; } } , true ) ; return deserializeHashList ( rawElementValues ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # keys ( java . lang . Object , java . lang . Object ) */
public Set < HK > keys ( H key , HK field ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; Set < byte [ ] > rawElementNames = execute ( new RedisCallback < Set < byte [ ] > > ( ) { public Set < byte [ ] > doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . slKeys ( rawKey , rawHashKey ) ; } } , true ) ; return deserializeHashKeys ( rawElementNames ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # add ( java . lang . Object , java . lang . Object , java . lang . Object , java . lang . Object ) */
public Long add ( H key , HK field , HK name , HV value ) { } }

implementation: return add ( key , field , name , value , 0 , TimeUnit . SECONDS ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # multiSet ( java . lang . Object , java . lang . Object , java . lang . Object , java . util . Collection ) */
public Long multiSet ( H key , HK field , HK name , Collection < HV > values ) { } }

implementation: return multiSet ( key , field , name , values , 0 , TimeUnit . SECONDS ) ;


signature:
public class DefaultSessionOfHashListOperations { /** * @ see SessionOfHashListOperations # exists ( java . lang . Object , java . lang . Object , java . lang . Object , java . lang . Object ) */
public Boolean exists ( H key , HK field , HK name , HV value ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] rawElementName = rawHashKey ( name ) ; final byte [ ] rawElementValue = rawHashValue ( value ) ; return execute ( new RedisCallback < Boolean > ( ) { public Boolean doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . slExists ( rawKey , rawHashKey , rawElementName , rawElementValue ) ; } } , true ) ;


signature:
public class GatewayServerSelector { /** * Gets the .
 * @ param list the list
 * @ return the gateway server */
public GatewayServer get ( List < GatewayServer > list ) { } }

implementation: if ( list . size ( ) == 0 ) { throw new IllegalArgumentException ( "list must not be zero size" ) ; } if ( list . size ( ) == 1 ) { return list . get ( 0 ) ; } if ( this . method == METHOD . RANDOM ) { return random ( list ) ; } return roundrobin ( list ) ;


signature:
public class GatewayServerSelector { /** * Random .
 * @ param list the list
 * @ return the gateway server */
GatewayServer random ( List < GatewayServer > list ) { } }

implementation: return list . get ( new Random ( ) . nextInt ( list . size ( ) ) ) ;


signature:
public class GatewayServerSelector { /** * Roundrobin .
 * @ param list the list
 * @ return the gateway server */
GatewayServer roundrobin ( List < GatewayServer > list ) { } }

implementation: int index = this . seq . getAndIncrement ( ) ; if ( index < 0 ) { this . seq . set ( 0 ) ; index = 0 ; } final int size = list . size ( ) ; if ( index != 0 && index >= size ) { index = index % size ; } return list . get ( index ) ;


signature:
public class BinaryRedisCluster { /** * Strings */
public Long append ( final byte [ ] key , final byte [ ] value ) { } }

implementation: client . append ( key , value ) ; return client . getIntegerReply ( ) ;


signature:
public class BinaryRedisCluster { /** * Sets */
public Long sadd ( final byte [ ] key , final byte [ ] ... members ) { } }

implementation: client . sadd ( key , members ) ; return client . getIntegerReply ( ) ;


signature:
public class BinaryRedisCluster { /** * Gets the binary tupled set .
 * @ return the binary tupled set */
private Set < Tuple > getBinaryTupledSet ( ) { } }

implementation: List < byte [ ] > membersWithScores = client . getBinaryMultiBulkReply ( ) ; Set < Tuple > set = new LinkedHashSet < Tuple > ( ) ; if ( membersWithScores == null ) { return set ; } Iterator < byte [ ] > iterator = membersWithScores . iterator ( ) ; if ( iterator == null ) { return set ; } while ( iterator . hasNext ( ) ) { set . add ( new Tuple ( iterator . next ( ) , Double . valueOf ( SafeEncoder . encode ( iterator . next ( ) ) ) ) ) ; } return set ;


signature:
public class RedisConnectionSync { /** * Send command .
 * @ param cmd the cmd
 * @ param args the args
 * @ return the redis connection */
public void sendCommand ( final Command cmd , final byte [ ] ... args ) { } }

implementation: log . trace ( "[RedisConnectionSync] Command={} {}" , cmd . name ( ) , toStringArgs ( args ) ) ; connect ( ) ; RedisProtocol . sendCommand ( outputStream , cmd , args ) ; this . pipelinedCommands ++ ;


signature:
public class RedisConnectionSync { /** * Connect . */
public void connect ( ) { } }

implementation:
if ( ! isConnected ( ) ) { try { socket = new Socket ( ) ; // - > @ wjw _ add
socket . setReuseAddress ( true ) ; socket . setKeepAlive ( true ) ; // Will monitor the TCP connection is
// valid
socket . setTcpNoDelay ( true ) ; // Socket buffer Whetherclosed , to
// ensure timely delivery of data
socket . setSoLinger ( true , 0 ) ; // Control calls close ( ) method ,
// the underlying socket is
// closed immediately
// < - @ wjw _ add
socket . connect ( new InetSocketAddress ( host , port ) , timeout ) ; socket . setSoTimeout ( timeout ) ; outputStream = new RedisOutputStream ( socket . getOutputStream ( ) ) ; inputStream = new RedisInputStream ( socket . getInputStream ( ) ) ; connectedTime = System . currentTimeMillis ( ) ; log . trace ( "[RedisConnectionSync] Connected {}" , toString ( ) ) ; } catch ( IOException ex ) { throw new JedisConnectionException ( ex ) ; } }


signature:
public class RedisConnectionSync { /** * Disconnect . */
public void disconnect ( ) { } }

implementation: if ( isConnected ( ) ) { try { inputStream . close ( ) ; outputStream . close ( ) ; if ( ! socket . isClosed ( ) ) { socket . close ( ) ; } disconnectedTime = System . currentTimeMillis ( ) ; log . trace ( "[RedisConnectionSync] Disconnected {}" , toString ( ) ) ; } catch ( IOException ex ) { throw new JedisConnectionException ( ex ) ; } }


signature:
public class RedisConnectionSync { /** * Gets the status code reply .
 * @ return the status code reply */
public String getStatusCodeReply ( ) { } }

implementation: flush ( ) ; this . pipelinedCommands -- ; final byte [ ] resp = ( byte [ ] ) RedisProtocol . read ( inputStream ) ; if ( null == resp ) { return null ; } else { return SafeEncoder . encode ( resp ) ; }


signature:
public class RedisConnectionSync { /** * Gets the object multi bulk reply .
 * @ return the object multi bulk reply */
@ SuppressWarnings ( "unchecked" ) public List < Object > getObjectMultiBulkReply ( ) { } }

implementation: flush ( ) ; this . pipelinedCommands -- ; return ( List < Object > ) RedisProtocol . read ( inputStream ) ;


signature:
public class RedisConnectionSync { /** * Gets the integer multi bulk reply .
 * @ return the integer multi bulk reply */
@ SuppressWarnings ( "unchecked" ) public List < Long > getIntegerMultiBulkReply ( ) { } }

implementation: flush ( ) ; this . pipelinedCommands -- ; return ( List < Long > ) RedisProtocol . read ( inputStream ) ;


signature:
public class ConfmasterService { /** * @ date 20140812
 * @ version 1.2 ~ 1.3
 * @ desc Gateway Affinity 적용을 위해 주키퍼의 znode 구조에 변경이 생겼다 . 기존 버전에는 이 노드가 없으니까 만들어주자 . */
public void updateZNodeDirectoryStructure ( ) throws NodeExistsException , MgmtZooKeeperException { } }

implementation: List < Cluster > clusterList = container . getAllCluster ( ) ; for ( Cluster cluster : clusterList ) { String affinityPath = PathUtil . pathOfGwAffinity ( cluster . getName ( ) ) ; if ( zk . isExists ( affinityPath ) ) { return ; } String gatewayAffinity = cluster . getGatewayAffinity ( context ) ; try { zk . createPersistentZNode ( affinityPath , gatewayAffinity . getBytes ( config . getCharset ( ) ) ) ; } catch ( UnsupportedEncodingException e ) { throw new AssertionError ( config . getCharset ( ) + " is unkown." ) ; } }


signature:
public class AbstractOperations { /** * Execute .
 * @ param < T > the generic type
 * @ param callback the callback
 * @ param b the b
 * @ return the t */
< T > T execute ( RedisCallback < T > callback , boolean b ) { } }

implementation: return template . execute ( callback , b ) ;


signature:
public class AbstractOperations { /** * Raw key .
 * @ param key the key
 * @ return the byte [ ] */
@ SuppressWarnings ( "unchecked" ) byte [ ] rawKey ( Object key ) { } }

implementation: Assert . notNull ( key , "non null key required" ) ; return keySerializer ( ) . serialize ( key ) ;


signature:
public class AbstractOperations { /** * Raw hash key .
 * @ param < HK > the generic type
 * @ param hashKey the hash key
 * @ return the byte [ ] */
@ SuppressWarnings ( "unchecked" ) < HK > byte [ ] rawHashKey ( HK hashKey ) { } }

implementation: Assert . notNull ( hashKey , "non null hash key required" ) ; return hashKeySerializer ( ) . serialize ( hashKey ) ;


signature:
public class AbstractOperations { /** * Raw keys .
 * @ param key the key
 * @ param otherKey the other key
 * @ return the byte [ ] [ ] */
byte [ ] [ ] rawKeys ( K key , K otherKey ) { } }

implementation: final byte [ ] [ ] rawKeys = new byte [ 2 ] [ ] ; rawKeys [ 0 ] = rawKey ( key ) ; rawKeys [ 1 ] = rawKey ( key ) ; return rawKeys ;


signature:
public class AbstractOperations { /** * Raw keys .
 * @ param key the key
 * @ param keys the keys
 * @ return the byte [ ] [ ] */
byte [ ] [ ] rawKeys ( K key , Collection < K > keys ) { } }

implementation: final byte [ ] [ ] rawKeys = new byte [ keys . size ( ) + ( key != null ? 1 : 0 ) ] [ ] ; int i = 0 ; if ( key != null ) { rawKeys [ i ++ ] = rawKey ( key ) ; } for ( K k : keys ) { rawKeys [ i ++ ] = rawKey ( k ) ; } return rawKeys ;


signature:
public class AbstractOperations { /** * Deserialize values .
 * @ param rawValues the raw values
 * @ return the sets the */
@ SuppressWarnings ( "unchecked" ) Set < V > deserializeValues ( Set < byte [ ] > rawValues ) { } }

implementation: return SerializationUtils . deserialize ( rawValues , valueSerializer ( ) ) ;


signature:
public class AbstractOperations { /** * Deserialize tuple values .
 * @ param rawValues the raw values
 * @ return the sets the */
@ SuppressWarnings ( "unchecked" ) Set < TypedTuple < V > > deserializeTupleValues ( Set < Tuple > rawValues ) { } }

implementation: Set < TypedTuple < V > > set = new LinkedHashSet < TypedTuple < V > > ( rawValues . size ( ) ) ; for ( Tuple rawValue : rawValues ) { set . add ( new DefaultTypedTuple ( valueSerializer ( ) . deserialize ( rawValue . getValue ( ) ) , rawValue . getScore ( ) ) ) ; } return set ;


signature:
public class AbstractOperations { /** * Deserialize values .
 * @ param rawValues the raw values
 * @ return the list */
@ SuppressWarnings ( "unchecked" ) List < V > deserializeValues ( List < byte [ ] > rawValues ) { } }


signature:
public class AbstractOperations { /** * Deserialize hash keys .
 * @ param < T > the generic type
 * @ param rawKeys the raw keys
 * @ return the sets the */
@ SuppressWarnings ( "unchecked" ) < T > Set < T > deserializeHashKeys ( Set < byte [ ] > rawKeys ) { } }

implementation: return SerializationUtils . deserialize ( rawKeys , hashKeySerializer ( ) ) ;


signature:
public class AbstractOperations { /** * Deserialize hash values .
 * @ param < T > the generic type
 * @ param rawValues the raw values
 * @ return the list */
@ SuppressWarnings ( "unchecked" ) < T > List < T > deserializeHashValues ( List < byte [ ] > rawValues ) { } }

implementation: return SerializationUtils . deserialize ( rawValues , hashValueSerializer ( ) ) ;


signature:
public class AbstractOperations { /** * Deserialize hash map .
 * @ param < HK > the generic type
 * @ param < HV > the generic type
 * @ param entries the entries
 * @ return the map */
@ SuppressWarnings ( "unchecked" ) < HK , HV > Map < HK , HV > deserializeHashMap ( Map < byte [ ] , byte [ ] > entries ) { } }

implementation:
// connection in pipeline / multi mode
if ( entries == null ) { return null ; } Map < HK , HV > map = new LinkedHashMap < HK , HV > ( entries . size ( ) ) ; for ( Map . Entry < byte [ ] , byte [ ] > entry : entries . entrySet ( ) ) { map . put ( ( HK ) deserializeHashKey ( entry . getKey ( ) ) , ( HV ) deserializeHashValue ( entry . getValue ( ) ) ) ; } return map ;


signature:
public class AbstractOperations { /** * Deserialize hash list .
 * @ param < HK > the generic type
 * @ param < HV > the generic type
 * @ param entries the entries
 * @ return the map */
< HK , HV > Map < HK , List < HV > > deserializeHashList ( Map < byte [ ] , List < byte [ ] > > entries ) { } }

implementation:
// connection in pipeline / multi mode
if ( entries == null ) { return null ; } Map < HK , List < HV > > map = new LinkedHashMap < HK , List < HV > > ( entries . size ( ) ) ; for ( Map . Entry < byte [ ] , List < byte [ ] > > entry : entries . entrySet ( ) ) { map . put ( ( HK ) deserializeHashKey ( entry . getKey ( ) ) , ( List < HV > ) deserializeHashValues ( entry . getValue ( ) ) ) ; } return map ;


signature:
public class AbstractOperations { /** * Deserialize hash set .
 * @ param < HK > the generic type
 * @ param < HV > the generic type
 * @ param entries the entries
 * @ return the map */
< HK , HV > Map < HK , Set < HV > > deserializeHashSet ( Map < byte [ ] , Set < byte [ ] > > entries ) { } }

implementation:
// connection in pipeline / multi mode
if ( entries == null ) { return null ; } Map < HK , Set < HV > > map = new LinkedHashMap < HK , Set < HV > > ( entries . size ( ) ) ; for ( Map . Entry < byte [ ] , Set < byte [ ] > > entry : entries . entrySet ( ) ) { map . put ( ( HK ) deserializeHashKey ( entry . getKey ( ) ) , ( Set < HV > ) deserializeValues ( entry . getValue ( ) ) ) ; } return map ;


signature:
public class GatewayAddress { /** * As list .
 * @ param addresses the addresses
 * @ return the list */
public static List < GatewayAddress > asList ( final String addresses ) { } }

implementation: if ( addresses == null ) { throw new IllegalArgumentException ( "addresses must not be null" ) ; } List < GatewayAddress > list = new ArrayList < GatewayAddress > ( ) ; final String [ ] tokens = addresses . split ( "," ) ; if ( tokens == null ) { return list ; } int id = 1 ; for ( String token : tokens ) { list . add ( new GatewayAddress ( id ++ , token ) ) ; } return list ;


signature:
public class GatewayAddress { /** * As list .
 * @ param addressList the addresses
 * @ return the list */
public static List < GatewayAddress > asList ( final List < String > addressList ) { } }

implementation: if ( addressList == null || addressList . size ( ) == 0 ) { throw new IllegalArgumentException ( "addresses must not be null" ) ; } List < GatewayAddress > list = new ArrayList < GatewayAddress > ( ) ; int id = 1 ; for ( String address : addressList ) { list . add ( new GatewayAddress ( id ++ , address ) ) ; } return list ;


signature:
public class GatewayAddress { /** * As list from domain .
 * @ param domainAddress the domain address
 * @ return the list */
public static List < GatewayAddress > asListFromDomain ( final String domainAddress ) { } }

implementation: if ( domainAddress == null ) { throw new IllegalArgumentException ( "domain address must not be null" ) ; } GatewayAddress domain = new GatewayAddress ( 0 , domainAddress ) ; InetAddress [ ] addresses ; try { addresses = InetAddress . getAllByName ( domain . getHost ( ) ) ; } catch ( Exception e ) { throw new IllegalArgumentException ( "invalid domain '" + domain + "' " + e . getMessage ( ) ) ; } List < GatewayAddress > list = new ArrayList < GatewayAddress > ( ) ; int id = 1 ; for ( InetAddress address : addresses ) { list . add ( new GatewayAddress ( id ++ , address . getHostAddress ( ) , domain . getPort ( ) ) ) ; } return list ;


signature:
public class GatewayAddress { /** * Parses the host .
 * @ param address the address
 * @ return the string */
public static String parseHost ( final String address ) { } }

implementation: int ep = address . indexOf ( ":" ) ; if ( ep == - 1 || ep == 0 ) { throw new IllegalArgumentException ( "invalid address '" + address + "'" ) ; } return address . substring ( 0 , ep ) . trim ( ) ;


signature:
public class GatewayAddress { /** * Parses the port .
 * @ param address the address
 * @ return the int */
public static int parsePort ( final String address ) { } }

implementation: int sp = address . indexOf ( ":" ) ; if ( sp == - 1 && sp + 1 >= address . length ( ) ) { throw new IllegalArgumentException ( "not found port '" + address + "'" ) ; } try { return Integer . parseInt ( address . substring ( sp + 1 , address . length ( ) ) . trim ( ) ) ; } catch ( NumberFormatException nfe ) { throw new IllegalArgumentException ( "bad port number '" + address + "'" ) ; }


signature:
public class RedisClusterClient { /** * Sets the .
 * @ param key the key
 * @ param value the value */
public void set ( final String key , final String value ) { } }

implementation: set ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Del .
 * @ param keys the keys */
public void del ( final String ... keys ) { } }

implementation: final byte [ ] [ ] bkeys = new byte [ keys . length ] [ ] ; for ( int i = 0 ; i < keys . length ; i ++ ) { bkeys [ i ] = SafeEncoder . encode ( keys [ i ] ) ; } del ( bkeys ) ;


signature:
public class RedisClusterClient { /** * Hset .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hset ( final String key , final String field , final String value ) { } }

implementation: hset ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( field ) , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Hget .
 * @ param key the key
 * @ param field the field */
public void hget ( final String key , final String field ) { } }

implementation: hget ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( field ) ) ;


signature:
public class RedisClusterClient { /** * Hsetnx .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hsetnx ( final String key , final String field , final String value ) { } }

implementation: hsetnx ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( field ) , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Hmget .
 * @ param key the key
 * @ param fields the fields */
public void hmget ( final String key , final String ... fields ) { } }

implementation: final byte [ ] [ ] bfields = new byte [ fields . length ] [ ] ; for ( int i = 0 ; i < bfields . length ; i ++ ) { bfields [ i ] = SafeEncoder . encode ( fields [ i ] ) ; } hmget ( SafeEncoder . encode ( key ) , bfields ) ;


signature:
public class RedisClusterClient { /** * Hincr by .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hincrBy ( final String key , final String field , final long value ) { } }

implementation: hincrBy ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( field ) , value ) ;


signature:
public class RedisClusterClient { /** * Rpush .
 * @ param key the key
 * @ param string the string */
public void rpush ( final String key , final String ... string ) { } }

implementation: rpush ( SafeEncoder . encode ( key ) , SafeEncoder . encodeMany ( string ) ) ;


signature:
public class RedisClusterClient { /** * Lpush .
 * @ param key the key
 * @ param string the string */
public void lpush ( final String key , final String ... string ) { } }

implementation: lpush ( SafeEncoder . encode ( key ) , SafeEncoder . encodeMany ( string ) ) ;


signature:
public class RedisClusterClient { /** * Lrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void lrange ( final String key , final long start , final long end ) { } }

implementation: lrange ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Ltrim .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void ltrim ( final String key , final long start , final long end ) { } }

implementation: ltrim ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Lset .
 * @ param key the key
 * @ param index the index
 * @ param value the value */
public void lset ( final String key , final long index , final String value ) { } }

implementation: lset ( SafeEncoder . encode ( key ) , index , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Lrem .
 * @ param key the key
 * @ param count the count
 * @ param value the value */
public void lrem ( final String key , long count , final String value ) { } }

implementation: lrem ( SafeEncoder . encode ( key ) , count , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Zrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrange ( final String key , final long start , final long end ) { } }

implementation: zrange ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Zrem .
 * @ param key the key
 * @ param members the members */
public void zrem ( final String key , final String ... members ) { } }

implementation: zrem ( SafeEncoder . encode ( key ) , SafeEncoder . encodeMany ( members ) ) ;


signature:
public class RedisClusterClient { /** * Zincrby .
 * @ param key the key
 * @ param score the score
 * @ param member the member */
public void zincrby ( final String key , final double score , final String member ) { } }

implementation: zincrby ( SafeEncoder . encode ( key ) , score , SafeEncoder . encode ( member ) ) ;


signature:
public class RedisClusterClient { /** * Zrevrank .
 * @ param key the key
 * @ param member the member */
public void zrevrank ( final String key , final String member ) { } }

implementation: zrevrank ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( member ) ) ;


signature:
public class RedisClusterClient { /** * Zrevrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrevrange ( final String key , final long start , final long end ) { } }

implementation: zrevrange ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Zrange with scores .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrangeWithScores ( final String key , final long start , final long end ) { } }

implementation: zrangeWithScores ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Zrevrange with scores .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrevrangeWithScores ( final String key , final long start , final long end ) { } }

implementation: zrevrangeWithScores ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Zcount .
 * @ param key the key
 * @ param min the min
 * @ param max the max */
public void zcount ( final String key , final String min , final String max ) { } }

implementation: zcount ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( min ) , SafeEncoder . encode ( max ) ) ;


signature:
public class RedisClusterClient { /** * Zrevrange by score with scores .
 * @ param key the key
 * @ param max the max
 * @ param min the min
 * @ param offset the offset
 * @ param count the count */
public void zrevrangeByScoreWithScores ( final String key , final String max , final String min , final int offset , final int count ) { } }

implementation: zrevrangeByScoreWithScores ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( max ) , SafeEncoder . encode ( min ) , offset , count ) ;


signature:
public class RedisClusterClient { /** * Zremrange by rank .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zremrangeByRank ( final String key , final long start , final long end ) { } }

implementation: zremrangeByRank ( SafeEncoder . encode ( key ) , start , end ) ;


signature:
public class RedisClusterClient { /** * Zremrange by score .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zremrangeByScore ( final String key , final double start , final double end ) { } }

implementation: zremrangeByScore ( SafeEncoder . encode ( key ) , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class RedisClusterClient { /** * Zremrange by score .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zremrangeByScore ( final String key , final String start , final String end ) { } }

implementation: zremrangeByScore ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( start ) , SafeEncoder . encode ( end ) ) ;


signature:
public class RedisClusterClient { /** * Lpushx .
 * @ param key the key
 * @ param string the string */
public void lpushx ( final String key , final String string ) { } }

implementation: lpushx ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( string ) ) ;


signature:
public class RedisClusterClient { /** * Rpushx .
 * @ param key the key
 * @ param string the string */
public void rpushx ( final String key , final String string ) { } }

implementation: rpushx ( SafeEncoder . encode ( key ) , SafeEncoder . encode ( string ) ) ;


signature:
public class RedisClusterClient { /** * Linsert .
 * @ param key the key
 * @ param where the where
 * @ param pivot the pivot
 * @ param value the value */
public void linsert ( final String key , final BinaryClient . LIST_POSITION where , final String pivot , final String value ) { } }

implementation: linsert ( SafeEncoder . encode ( key ) , where , SafeEncoder . encode ( pivot ) , SafeEncoder . encode ( value ) ) ;


signature:
public class RedisClusterClient { /** * Setbit .
 * @ param key the key
 * @ param offset the offset
 * @ param value the value */
public void setbit ( final String key , final long offset , final boolean value ) { } }

implementation: setbit ( SafeEncoder . encode ( key ) , offset , RedisProtocol . toByteArray ( value ? 1 : 0 ) ) ;


signature:
public class RedisClusterPipeline { /** * Synchronize pipeline by reading all responses . This operation close the
 * pipeline . In order to get return values from pipelined commands , capture
 * the different Response & lt ; ? & gt ; of the commands you execute . */
public void sync ( ) { } }

implementation: if ( this . client == null ) { return ; } List < Object > unformatted = null ; try { unformatted = this . client . getAll ( ) ; } catch ( Exception e ) { this . brokenResource = true ; throw new GatewayException ( "gateway=" + this . server + ", connect=" + this . redis . connectInfo ( ) , e ) ; } if ( unformatted == null ) { return ; } for ( Object o : unformatted ) { try { generateResponse ( o ) ; } catch ( Exception ignored ) { } }


signature:
public class RedisClusterPipeline { /** * Syncronize pipeline by reading all responses . This operation close the
 * pipeline . Whenever possible try to avoid using this version and use
 * Pipeline . sync ( ) as it won ' t go through all the responses and generate the
 * right response type ( usually it is a waste of time ) .
 * @ return A list of all the responses in the order you executed them .
 * @ see sync */
public List < Object > syncAndReturnAll ( ) { } }

implementation: final List < Object > formatted = new ArrayList < Object > ( ) ; if ( client == null ) { return formatted ; } List < Object > unformatted = null ; try { unformatted = client . getAll ( ) ; } catch ( Exception e ) { this . brokenResource = true ; throw new GatewayException ( "gateway=" + this . server + ", connect=" + this . redis . connectInfo ( ) , e ) ; } if ( unformatted == null ) { return formatted ; } for ( Object o : unformatted ) { try { formatted . add ( generateResponse ( o ) . get ( ) ) ; } catch ( JedisDataException e ) { formatted . add ( e ) ; } } return formatted ;


signature:
public class RedisClusterPipeline { /** * Triples */
public Response < List < String > > slget ( final String key , final String field , final String name ) { } }

implementation: return this . executeCallback ( new PipelineCallback < Response < List < String > > > ( ) { public Response < List < String > > doInPipeline ( ) { client . slget ( keyspace , key , field , name ) ; return getResponse ( BuilderFactory . STRING_LIST_NOTNULL ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class RedisConnection { /** * Send command .
 * @ param cmd the cmd
 * @ param args the args
 * @ return the redis connection */
protected RedisConnection sendCommand ( final Command cmd , final String ... args ) { } }

implementation: final byte [ ] [ ] bargs = new byte [ args . length ] [ ] ; for ( int i = 0 ; i < args . length ; i ++ ) { bargs [ i ] = SafeEncoder . encode ( args [ i ] ) ; } return sendCommand ( cmd , bargs ) ;


signature:
public class MembershipGrantWorkflow { /** * When all PGSes in a PG are green , it is able to
 * clean mgen - history of PG to prevent history from growing
 * too long to cause slow operations . */
private void cleanMGen ( ) throws MgmtZooKeeperException { } }

implementation: try { PartitionGroup . PartitionGroupData pgM = pg . clonePersistentData ( ) ; pgM . cleanMGen ( config . getClusterPgMgenHistorySize ( ) ) ; zk . setData ( pg . getPath ( ) , pgM . toBytes ( ) , - 1 ) ; pg . setPersistentData ( pgM ) ; } catch ( Exception e ) { throw new MgmtZooKeeperException ( "Clean mgen history of " + pg + " fail, " + e . getMessage ( ) ) ; }


signature:
public class RedisCluster { /** * Hashes */
public Long hdel ( final String key , final String ... fields ) { } }

implementation: client . hdel ( key , fields ) ; return client . getIntegerReply ( ) ;


signature:
public class RedisCluster { /** * Lists */
public String lindex ( final String key , final long index ) { } }

implementation: client . lindex ( key , index ) ; return client . getBulkReply ( ) ;


signature:
public class RedisCluster { /** * Sorted Sets */
public Long zadd ( final String key , final double score , final String member ) { } }

implementation: client . zadd ( key , score , member ) ; return client . getIntegerReply ( ) ;


signature:
public class RedisCluster { /** * Gets the tupled set .
 * @ return the tupled set */
private Set < Tuple > getTupledSet ( ) { } }

implementation: List < String > membersWithScores = client . getMultiBulkReply ( ) ; Set < Tuple > set = new LinkedHashSet < Tuple > ( ) ; Iterator < String > iterator = membersWithScores . iterator ( ) ; while ( iterator . hasNext ( ) ) { set . add ( new Tuple ( iterator . next ( ) , Double . valueOf ( iterator . next ( ) ) ) ) ; } return set ;


signature:
public class LeaderElectionSupport { /** * Start the election process . This method will create a leader offer ,
 * determine its status , and either become the leader or become ready . If an
 * instance of { @ link ZooKeeper } has not yet been configured by the user , a
 * new instance is created using the connectString and sessionTime
 * specified .
 * Any ( anticipated ) failures result in a failed event being sent to all
 * listeners . */
public synchronized void start ( ) { } }

implementation: state = State . START ; dispatchEvent ( LeaderElectionEventType . START ) ; logger . info ( "Starting leader election support" ) ; if ( zooKeeper == null ) { throw new IllegalStateException ( "No instance of zookeeper provided. Hint: use setZooKeeper()" ) ; } if ( hostName == null ) { throw new IllegalStateException ( "No hostname provided. Hint: use setHostName()" ) ; } try { makeOffer ( ) ; determineElectionStatus ( ) ; } catch ( KeeperException e ) { becomeFailed ( e ) ; } catch ( InterruptedException e ) { becomeFailed ( e ) ; }


signature:
public class LeaderElectionSupport { /** * Stops all election services , revokes any outstanding leader offers , and
 * disconnects from ZooKeeper . */
public synchronized void stop ( ) { } }

implementation: state = State . STOP ; dispatchEvent ( LeaderElectionEventType . STOP_START ) ; logger . info ( "Stopping leader election support" ) ; if ( leaderOffer != null ) { try { zooKeeper . delete ( leaderOffer . getNodePath ( ) , - 1 ) ; logger . info ( "Removed leader offer {}" , leaderOffer . getNodePath ( ) ) ; } catch ( InterruptedException e ) { becomeFailed ( e ) ; } catch ( KeeperException e ) { becomeFailed ( e ) ; } } dispatchEvent ( LeaderElectionEventType . STOP_COMPLETE ) ;


signature:
public class LeaderElectionSupport { /** * Fetch the ( user supplied ) hostname of the current leader . Note that by
 * the time this method returns , state could have changed so do not depend
 * on this to be strongly consistent . This method has to read all leader
 * offers from ZooKeeper to determine who the leader is ( i . e . there is no
 * caching ) so consider the performance implications of frequent invocation .
 * If there are no leader offers this method returns null .
 * @ return hostname of the current leader
 * @ throws KeeperException
 * @ throws InterruptedException */
public String getLeaderHostName ( ) throws KeeperException , InterruptedException { } }

implementation: List < LeaderOffer > leaderOffers = toLeaderOffers ( zooKeeper . getChildren ( rootNodeName , false ) ) ; if ( leaderOffers . size ( ) > 0 ) { return leaderOffers . get ( 0 ) . getHostName ( ) ; } return null ;


signature:
public class RedisClusterConnectionFactory { /** * @ see org . springframework . data . redis . connection . RedisConnectionFactory # getConnection ( ) */
public RedisClusterConnection getConnection ( ) { } }

implementation: final RedisClusterConnection connection = new RedisClusterConnection ( this . client ) ; connection . setConvertPipelineAndTxResults ( this . convertPipelineAndTxResults ) ; return postProcessConnection ( connection ) ;


signature:
public class RedisClusterConnectionFactory { /** * @ see org . springframework . dao . support . PersistenceExceptionTranslator # translateExceptionIfPossible ( java . lang . RuntimeException ) */
public DataAccessException translateExceptionIfPossible ( RuntimeException ex ) { } }

implementation: if ( ex instanceof GatewayException ) { return exceptionConverter . convert ( ex ) ; } return null ;


signature:
public class DefaultBoundSessionOfHashListOperations { /** * @ see BoundSessionOfHashListOperations # get ( java . lang . Object ) */
public List < HV > get ( HK key ) { } }

implementation: return ops . get ( getKey ( ) , getField ( ) , key ) ;


signature:
public class DefaultBoundSessionOfHashListOperations { /** * @ see BoundSessionOfHashListOperations # multiGet ( java . util . Collection ) */
public Map < HK , List < HV > > multiGet ( Collection < HK > keys ) { } }

implementation: return ops . multiGet ( getKey ( ) , getField ( ) , keys ) ;


signature:
public class GatewayClient { /** * execute to action ( redis in command )
 * @ param < T > the generic type
 * @ param action { @ link RedisClusterCallback }
 * @ return object returned by the action */
public < T > T execute ( RedisClusterCallback < T > action ) { } }

implementation: GatewayException exception = null ; for ( int i = 0 ; i <= this . maxRetry ; i ++ ) { try { return executeCallback ( action , i ) ; } catch ( GatewayException e ) { if ( ! e . isRetryable ( ) ) { throw e ; } else { exception = e ; if ( i < this . maxRetry ) { log . warn ( "[GatewayClient] Failed to action. auto retrying ... " + ( i + 1 ) + "/" + this . maxRetry , e ) ; } } } } throw exception ;


signature:
public class GatewayClient { /** * time , retry , gateway server information . */
String toExecuteInfo ( final int tryCount , final long startedTime , final GatewayServer server , final RedisCluster redis ) { } }

implementation: final StringBuilder sb = new StringBuilder ( ) ; final long executedTime = System . currentTimeMillis ( ) - startedTime ; sb . append ( "time=" ) . append ( executedTime ) . append ( ", " ) ; sb . append ( "retry=" ) . append ( tryCount ) . append ( ", " ) ; sb . append ( "gateway=" ) . append ( server ) ; if ( redis != null ) { sb . append ( ", " ) . append ( "connect=" ) . append ( redis . connectInfo ( ) ) ; } return sb . toString ( ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # ping ( ) */
public String ping ( ) { } }

implementation: return this . execute ( new RedisClusterCallback < String > ( ) { public String doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . ping ( ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . NOT_MATCHED ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # del ( java . lang . String ) */
public Long del ( final String ... keys ) { } }

implementation: return this . execute ( new RedisClusterCallback < Long > ( ) { public Long doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . del ( keys ) ; } public int getPartitionNumber ( ) { if ( keys == null || keys . length < 1 ) { return GatewayPartitionNumber . NOT_MATCHED ; } return GatewayPartitionNumber . get ( keys [ 0 ] ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see BinaryRedisClusterCommands # exists ( byte [ ] ) */
public Boolean exists ( final byte [ ] key ) { } }

implementation: return this . execute ( new RedisClusterCallback < Boolean > ( ) { public Boolean doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . exists ( key ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see BinaryRedisClusterCommands # set ( byte [ ] . . . ) */
@ Override public String set ( final byte [ ] ... args ) { } }

implementation: return this . execute ( new RedisClusterCallback < String > ( ) { public String doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . set ( args ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( args [ 0 ] ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see BinaryRedisClusterCommands # setbit ( byte [ ] , long , byte [ ] ) */
public Boolean setbit ( final byte [ ] key , final long offset , final byte [ ] value ) { } }

implementation: return this . execute ( new RedisClusterCallback < Boolean > ( ) { public Boolean doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . setbit ( key , offset , value ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # linsert ( java . lang . String , redis . clients . jedis . BinaryClient . LIST _ POSITION , java . lang . String , java . lang . String ) */
public Long linsert ( final String key , final LIST_POSITION where , final String pivot , final String value ) { } }

implementation: return this . execute ( new RedisClusterCallback < Long > ( ) { public Long doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . linsert ( key , where , pivot , value ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zadd ( java . lang . String , java . util . Map ) */
public Long zadd ( final String key , final Map < Double , String > scoreMembers ) { } }

implementation: return this . execute ( new RedisClusterCallback < Long > ( ) { public Long doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zadd ( key , scoreMembers ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zcount ( java . lang . String , double , double ) */
public Long zcount ( final String key , final double min , final double max ) { } }

implementation: return this . execute ( new RedisClusterCallback < Long > ( ) { public Long doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zcount ( key , min , max ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zincrby ( java . lang . String , double , java . lang . String ) */
public Double zincrby ( final String key , final double score , final String member ) { } }

implementation: return this . execute ( new RedisClusterCallback < Double > ( ) { public Double doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zincrby ( key , score , member ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zrangeByScore ( java . lang . String , double , double ) */
public Set < String > zrangeByScore ( final String key , final double min , final double max ) { } }

implementation: return this . execute ( new RedisClusterCallback < Set < String > > ( ) { public Set < String > doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zrangeByScore ( key , min , max ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zremrangeByRank ( java . lang . String , long , long ) */
public Long zremrangeByRank ( final String key , final long start , final long end ) { } }

implementation: return this . execute ( new RedisClusterCallback < Long > ( ) { public Long doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zremrangeByRank ( key , start , end ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # zscore ( java . lang . String , java . lang . String ) */
public Double zscore ( final String key , final String value ) { } }

implementation: return this . execute ( new RedisClusterCallback < Double > ( ) { public Double doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . zscore ( key , value ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # hgetAll ( java . lang . String ) */
public Map < String , String > hgetAll ( final String key ) { } }

implementation: return this . execute ( new RedisClusterCallback < Map < String , String > > ( ) { public Map < String , String > doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . hgetAll ( key ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see RedisClusterCommands # hmset ( java . lang . String , java . util . Map ) */
public String hmset ( final String key , final Map < String , String > tuple ) { } }

implementation: return this . execute ( new RedisClusterCallback < String > ( ) { public String doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . hmset ( key , tuple ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . WRITE ; } } ) ;


signature:
public class GatewayClient { /** * @ see TriplesRedisClusterCommands # slget ( java . lang . String , java . lang . String , java . lang . String ) */
public List < String > slget ( final String key , final String field , final String name ) { } }

implementation: return this . execute ( new RedisClusterCallback < List < String > > ( ) { public List < String > doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . slget ( key , field , name ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class GatewayClient { /** * @ see TriplesRedisClusterCommands # ssmget ( java . lang . String , java . lang . String , java . lang . String [ ] ) */
public Map < String , Set < String > > ssmget ( final String key , final String field , final String ... names ) { } }

implementation: return this . execute ( new RedisClusterCallback < Map < String , Set < String > > > ( ) { public Map < String , Set < String > > doInRedisCluster ( RedisCluster redisCluster ) { return redisCluster . ssmget ( key , field , names ) ; } public int getPartitionNumber ( ) { return GatewayPartitionNumber . get ( key ) ; } public AffinityState getState ( ) { return AffinityState . READ ; } } ) ;


signature:
public class HealthCheckManager { /** * @ see java . lang . Runnable # run ( ) */
public void run ( ) { } }

implementation: for ( final GatewayServer server : this . serverData . getServers ( ) ) { if ( ! server . isExist ( ) ) { continue ; } Runnable handler = new Runnable ( ) { public void run ( ) { if ( ! server . isExist ( ) ) { return ; } final boolean result = server . ping ( ) ; server . setValid ( result ) ; log . debug ( "[HealthCheck] Result {}" , server ) ; } } ; this . threadPool . execute ( handler ) ; }


signature:
public class GatewayServerClear { /** * Shutdown . */
public void shutdown ( ) { } }

implementation: try { this . scheduler . shutdownNow ( ) ; } catch ( Exception ignored ) { } for ( final WaitingServer server : list ) { try { server . destroy ( ) ; log . info ( "[GatewayServerClear] Destroy gateway server {}" , server ) ; } catch ( Exception ignored ) { } } list . clear ( ) ;


signature:
public class GatewayServerSync { /** * Ping .
 * @ return true , if successful
 * @ throws HealthCheckException the health check exception */
public boolean ping ( ) { } }

implementation: try { return ping ( getResource ( ) ) ; } catch ( Exception e ) { log . error ( "[GatewayServer] Failed to health check " + toString ( ) , e ) ; } return false ;


signature:
public class RedisProtocol { /** * Send command .
 * @ param os the os
 * @ param command the command
 * @ param args the args */
public static void sendCommand ( final RedisOutputStream os , final Command command , final byte [ ] ... args ) { } }

implementation: sendCommand ( os , command . raw , args ) ;


signature:
public class RedisProtocol { /** * Process error .
 * @ param is the is */
private static void processError ( final RedisInputStream is ) { } }

implementation: String message = is . readLine ( ) ; log . trace ( "[RedisProtocol] Reply error. -{}" , message ) ; throw new JedisDataException ( message ) ;


signature:
public class RedisProtocol { /** * Process .
 * @ param is the is
 * @ return the object */
private static Object process ( final RedisInputStream is ) { } }

implementation: byte b = is . readByte ( ) ; if ( b == MINUS_BYTE ) { processError ( is ) ; return null ; } else if ( b == ASTERISK_BYTE ) { return processMultiBulkReply ( is ) ; } else if ( b == COLON_BYTE ) { return processInteger ( is ) ; } else if ( b == DOLLAR_BYTE ) { return processBulkReply ( is ) ; } else if ( b == PLUS_BYTE ) { return processStatusCodeReply ( is ) ; } else { throw new JedisConnectionException ( "Unknown reply: " + ( char ) b ) ; }


signature:
public class RedisProtocol { /** * Process status code reply .
 * @ param is the is
 * @ return the byte [ ] */
private static byte [ ] processStatusCodeReply ( final RedisInputStream is ) { } }

implementation: final String statusCode = is . readLine ( ) ; log . trace ( "[RedisProtocol] Reply status-code. +{}" , statusCode ) ; return SafeEncoder . encode ( statusCode ) ;


signature:
public class RedisProtocol { /** * Process bulk reply .
 * @ param is the is
 * @ return the byte [ ] */
private static byte [ ] processBulkReply ( final RedisInputStream is ) { } }

implementation:
int len = Integer . parseInt ( is . readLine ( ) ) ; log . trace ( "[RedisProtocol] Reply bulk-reply. ${}" , len ) ; if ( len == - 1 ) { return null ; } byte [ ] read = new byte [ len ] ; int offset = 0 ; while ( offset < len ) { offset += is . read ( read , offset , ( len - offset ) ) ; } // read 2 more bytes for the command delimiter
is . readByte ( ) ; is . readByte ( ) ; return read ;


signature:
public class RedisProtocol { /** * Process integer .
 * @ param is the is
 * @ return the long */
private static Long processInteger ( final RedisInputStream is ) { } }

implementation: final String num = is . readLine ( ) ; log . trace ( "[RedisProtocol] Reply integer. :{}" , num ) ; return Long . valueOf ( num ) ;


signature:
public class RedisProtocol { /** * Process multi bulk reply .
 * @ param is the is
 * @ return the list */
private static List < Object > processMultiBulkReply ( final RedisInputStream is ) { } }

implementation: int num = Integer . parseInt ( is . readLine ( ) ) ; log . trace ( "[RedisProtocol] Reply multi-bulk-reply. *{}" , num ) ; if ( num == - 1 ) { return null ; } List < Object > ret = new ArrayList < Object > ( num ) ; for ( int i = 0 ; i < num ; i ++ ) { try { ret . add ( process ( is ) ) ; } catch ( JedisDataException e ) { ret . add ( e ) ; } } return ret ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # get ( java . lang . Object , java . lang . Object , java . lang . Object ) */
public Set < HV > get ( H key , HK field , HK name ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] rawElementName = rawHashKey ( name ) ; Set < byte [ ] > rawElementValues = execute ( new RedisCallback < Set < byte [ ] > > ( ) { public Set < byte [ ] > doInRedis ( RedisConnection connection ) { return ( ( RedisClusterConnection ) connection ) . ssGet ( rawKey , rawHashKey , rawElementName ) ; } } , true ) ; return ( Set < HV > ) deserializeValues ( rawElementValues ) ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # mulitGet ( java . lang . Object , java . lang . Object , java . util . Collection ) */
public Map < HK , Set < HV > > mulitGet ( H key , HK field , Collection < HK > names ) { } }

implementation: if ( names . isEmpty ( ) ) { return new HashMap < HK , Set < HV > > ( ) ; } final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] [ ] rawElementNames = new byte [ names . size ( ) ] [ ] ; int count = 0 ; for ( HK name : names ) { rawElementNames [ count ++ ] = rawHashKey ( name ) ; } Map < byte [ ] , Set < byte [ ] > > rawElementValues = execute ( new RedisCallback < Map < byte [ ] , Set < byte [ ] > > > ( ) { public Map < byte [ ] , Set < byte [ ] > > doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . ssMGet ( rawKey , rawHashKey , rawElementNames ) ; } } , true ) ; return deserializeHashSet ( rawElementValues ) ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # keys ( java . lang . Object ) */
public Set < HK > keys ( H key ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; Set < byte [ ] > rawHashKeys = execute ( new RedisCallback < Set < byte [ ] > > ( ) { public Set < byte [ ] > doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . ssKeys ( rawKey ) ; } } , true ) ; return deserializeHashKeys ( rawHashKeys ) ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # multiSet ( java . lang . Object , java . lang . Object , java . lang . Object , java . util . Collection , long , java . util . concurrent . TimeUnit ) */
public Long multiSet ( H key , HK field , HK name , Collection < HV > values , long timeout , TimeUnit unit ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final byte [ ] rawHashKey = rawHashKey ( field ) ; final byte [ ] rawElementName = rawHashKey ( name ) ; final byte [ ] [ ] rawElementValues = new byte [ values . size ( ) ] [ ] ; int count = 0 ; for ( HV value : values ) { rawElementValues [ count ++ ] = rawHashValue ( value ) ; } final long expireSeconds = unit . toSeconds ( timeout ) ; return execute ( new RedisCallback < Long > ( ) { public Long doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . ssSet ( rawKey , rawHashKey , rawElementName , expireSeconds , rawElementValues ) ; } } , true ) ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # del ( java . lang . Object ) */
public Long del ( H key ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; return execute ( new RedisCallback < Long > ( ) { public Long doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . ssDel ( rawKey ) ; } } , true ) ;


signature:
public class DefaultSessionOfHashSetOperations { /** * @ see SessionOfHashSetOperations # expire ( java . lang . Object , long , java . util . concurrent . TimeUnit ) */
public Long expire ( H key , long timeout , TimeUnit unit ) { } }

implementation: final byte [ ] rawKey = rawKey ( key ) ; final long expireSeconds = unit . toSeconds ( timeout ) ; return execute ( new RedisCallback < Long > ( ) { public Long doInRedis ( RedisConnection connection ) throws DataAccessException { return ( ( RedisClusterConnection ) connection ) . ssExpire ( rawKey , expireSeconds ) ; } } , true ) ;


signature:
public class DefaultTypedTuple { /** * @ see java . lang . Comparable # compareTo ( java . lang . Object ) */
public int compareTo ( Double o ) { } }

implementation: Double d = ( score == null ? Double . valueOf ( 0 ) : score ) ; Double a = ( o == null ? Double . valueOf ( 0 ) : o ) ; return d . compareTo ( a ) ;


signature:
public class TriplesRedisClusterClient { /** * Slget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void slget ( final String keyspace , final String uid , final String serviceCode , final String key ) { } }

implementation: slget ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Slmget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param keys the keys */
public void slmget ( final String keyspace , final String uid , final String serviceCode , final String ... keys ) { } }

implementation: final byte [ ] [ ] bkeys = new byte [ keys . length ] [ ] ; for ( int i = 0 ; i < keys . length ; i ++ ) { bkeys [ i ] = SafeEncoder . encode ( keys [ i ] ) ; } slmget ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , bkeys ) ;


signature:
public class TriplesRedisClusterClient { /** * Slkeys .
 * @ param keyspace the keyspace
 * @ param uid the uid */
public void slkeys ( final String keyspace , final String uid ) { } }

implementation: slkeys ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Sldel .
 * @ param keyspace the keyspace
 * @ param uid the uid */
public void sldel ( final String keyspace , final String uid ) { } }

implementation: sldel ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Slrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param values the values */
public void slrem ( final String keyspace , final String uid , final String serviceCode , final String key , final String [ ] values ) { } }

implementation: final byte [ ] [ ] bvalues = new byte [ values . length ] [ ] ; for ( int i = 0 ; i < values . length ; i ++ ) { bvalues [ i ] = SafeEncoder . encode ( values [ i ] ) ; } slrem ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) , bvalues ) ;


signature:
public class TriplesRedisClusterClient { /** * Slcount .
 * @ param keyspace the keyspace
 * @ param uid the uid */
public void slcount ( final String keyspace , final String uid ) { } }

implementation: slcount ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Slexists .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void slexists ( final String keyspace , final String uid , final String serviceCode , final String key ) { } }

implementation: slexists ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Slmexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param expireMillis the expire millis
 * @ param serviceCode the service code
 * @ param keys the keys */
public void slmexpire ( final String keyspace , final String uid , final long expireMillis , final String serviceCode , final String ... keys ) { } }

implementation: final byte [ ] [ ] bkeys = new byte [ keys . length ] [ ] ; for ( int i = 0 ; i < keys . length ; i ++ ) { bkeys [ i ] = SafeEncoder . encode ( keys [ i ] ) ; } slmexpire ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , expireMillis , SafeEncoder . encode ( serviceCode ) , bkeys ) ;


signature:
public class TriplesRedisClusterClient { /** * Slvals .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void slvals ( final String keyspace , final String uid , final String serviceCode ) { } }

implementation: slvals ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Slreplace .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireTime the expire time
 * @ param oldValue the old value
 * @ param newValue the new value */
public void slreplace ( final String keyspace , final String uid , final String serviceCode , final String key , final long expireTime , final String oldValue , final String newValue ) { } }

implementation: slreplace ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) , expireTime , SafeEncoder . encode ( oldValue ) , SafeEncoder . encode ( newValue ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Ssget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void ssget ( final String keyspace , final String uid , final String serviceCode , final String key ) { } }

implementation: ssget ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Sskeys .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void sskeys ( final String keyspace , final String uid , final String serviceCode , final String key ) { } }

implementation: sskeys ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Ssadd .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values */
public void ssadd ( final String keyspace , final String uid , final String serviceCode , final String key , final long expireMillis , final String ... values ) { } }

implementation: final byte [ ] [ ] bvalues = new byte [ values . length ] [ ] ; for ( int i = 0 ; i < values . length ; i ++ ) { bvalues [ i ] = SafeEncoder . encode ( values [ i ] ) ; } ssadd ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) , expireMillis , bvalues ) ;


signature:
public class TriplesRedisClusterClient { /** * Ssdel .
 * @ param keyspace the keyspace
 * @ param uid the uid */
public void ssdel ( final String keyspace , final String uid ) { } }

implementation: ssdel ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Sscount .
 * @ param keyspace the keyspace
 * @ param uid the uid */
public void sscount ( final String keyspace , final String uid ) { } }

implementation: sscount ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) ) ;


signature:
public class TriplesRedisClusterClient { /** * Ssexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param value the value
 * @ param expireMillis the expire millis */
public void ssexpire ( final String keyspace , final String uid , final String serviceCode , final String key , final String value , final long expireMillis ) { } }

implementation: ssexpire ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) , SafeEncoder . encode ( key ) , SafeEncoder . encode ( value ) , expireMillis ) ;


signature:
public class TriplesRedisClusterClient { /** * Ssvals .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void ssvals ( final String keyspace , final String uid , final String serviceCode ) { } }

implementation: ssvals ( SafeEncoder . encode ( keyspace ) , SafeEncoder . encode ( uid ) , SafeEncoder . encode ( serviceCode ) ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void slget ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key ) { } }

implementation: sendCommand ( Command . S3LGET , keyspace , uid , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slmget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void slmget ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] ... key ) { } }

implementation: byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key ) ; sendCommand ( Command . S3LMGET , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slkeys .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void slkeys ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3LKEYS , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Sladd .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param value the value */
public void sladd ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] value ) { } }

implementation: sendCommand ( Command . S3LADD , keyspace , uid , serviceCode , key , value , RedisProtocol . toByteArray ( expireMillis ) ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Sladd .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values */
public void sladd ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] ... values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , expireMillis , values ) ; sendCommand ( Command . S3LADD , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void slrem ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3LREM , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param values the values */
public void slrem ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final byte [ ] ... values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , values ) ; sendCommand ( Command . S3LREM , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slmrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param keys the keys */
public void slmrem ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] ... keys ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , keys ) ; sendCommand ( Command . S3LMREM , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slcount .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void slcount ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3LCOUNT , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slexists .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param value the value */
public void slexists ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final byte [ ] value ) { } }

implementation: sendCommand ( Command . S3LEXISTS , keyspace , uid , serviceCode , key , value ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slmexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param expireMillis the expire millis
 * @ param serviceCode the service code
 * @ param keys the keys */
public void slmexpire ( final byte [ ] keyspace , final byte [ ] uid , long expireMillis , final byte [ ] serviceCode , final byte [ ] ... keys ) { } }

implementation: byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , expireMillis , keys ) ; sendCommand ( Command . S3LMEXPIRE , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param expireMillis the expire millis */
public void slexpire ( final byte [ ] keyspace , final byte [ ] uid , long expireMillis ) { } }

implementation: sendCommand ( Command . S3EXPIRE , keyspace , uid , RedisProtocol . toByteArray ( expireMillis ) ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param expireMillis the expire millis */
public void slexpire ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , long expireMillis ) { } }

implementation: sendCommand ( Command . S3LEXPIRE , keyspace , uid , RedisProtocol . toByteArray ( expireMillis ) , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slttl .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void slttl ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key ) { } }

implementation: sendCommand ( Command . S3LTTL , keyspace , uid , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slset .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values */
public void slset ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] ... values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , expireMillis , values ) ; sendCommand ( Command . S3LSET , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slreplace .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param oldValue the old value
 * @ param newValue the new value */
public void slreplace ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] oldValue , final byte [ ] newValue ) { } }

implementation: sendCommand ( Command . S3LREPLACE , keyspace , uid , serviceCode , key , oldValue , newValue , RedisProtocol . toByteArray ( expireMillis ) ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Slvals
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void slvals ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3LVALS , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void ssget ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key ) { } }

implementation: sendCommand ( Command . S3SGET , keyspace , uid , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssmget .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void ssmget ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] ... key ) { } }

implementation: byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key ) ; sendCommand ( Command . S3SMGET , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Sskeys .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void sskeys ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3SKEYS , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssadd .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param value the value */
public void ssadd ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] value ) { } }

implementation: sendCommand ( Command . S3SADD , keyspace , uid , serviceCode , key , value , RedisProtocol . toByteArray ( expireMillis ) ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssadd .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values */
public void ssadd ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] [ ] values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , expireMillis , values ) ; sendCommand ( Command . S3SADD , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssset .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values */
public void ssset ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] [ ] values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , expireMillis , values ) ; sendCommand ( Command . S3SSET , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void ssrem ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3SREM , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssrem .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param values the values */
public void ssrem ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final byte [ ] [ ] values ) { } }

implementation: final byte [ ] [ ] params = toByteArrays ( keyspace , uid , serviceCode , key , values ) ; sendCommand ( Command . S3SREM , params ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Sscount .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void sscount ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3SCOUNT , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssexists .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void ssexists ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key ) { } }

implementation: sendCommand ( Command . S3SEXISTS , keyspace , uid , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssexpire .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis */
public void ssexpire ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , long expireMillis ) { } }

implementation: sendCommand ( Command . S3SEXPIRE , keyspace , uid , RedisProtocol . toByteArray ( expireMillis ) , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssttl .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key */
public void ssttl ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key ) { } }

implementation: sendCommand ( Command . S3STTL , keyspace , uid , serviceCode , key ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * Ssvals .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code */
public void ssvals ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode ) { } }

implementation: sendCommand ( Command . S3SVALS , keyspace , uid , serviceCode ) ;


signature:
public class BinaryTriplesRedisClusterClient { /** * To byte arrays .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param expireMillis the expire millis
 * @ param keys the keys
 * @ return the byte [ ] [ ] */
private byte [ ] [ ] toByteArrays ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final long expireMillis , final byte [ ] [ ] keys ) { } }

implementation: final byte [ ] [ ] allArgs = new byte [ keys . length + 4 ] [ ] ; int index = 0 ; allArgs [ index ++ ] = keyspace ; allArgs [ index ++ ] = uid ; allArgs [ index ++ ] = serviceCode ; allArgs [ index ++ ] = RedisProtocol . toByteArray ( expireMillis ) ; for ( int i = 0 ; i < keys . length ; i ++ ) { allArgs [ index ++ ] = keys [ i ] ; } return allArgs ;


signature:
public class BinaryTriplesRedisClusterClient { /** * To byte arrays .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ return the byte [ ] [ ] */
private byte [ ] [ ] toByteArrays ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] [ ] key ) { } }

implementation: final byte [ ] [ ] allArgs = new byte [ key . length + 3 ] [ ] ; int index = 0 ; allArgs [ index ++ ] = keyspace ; allArgs [ index ++ ] = uid ; allArgs [ index ++ ] = serviceCode ; for ( int i = 0 ; i < key . length ; i ++ ) { allArgs [ index ++ ] = key [ i ] ; } return allArgs ;


signature:
public class RedisDecoder { /** * Process error .
 * @ param is the is */
private boolean processError ( ByteBuf in ) { } }

implementation: int length = lineLength ( in ) ; if ( length == - 1 ) { return false ; } in . skipBytes ( length ) ; return true ;


signature:
public class RedisDecoder { /** * Process multi bulk reply .
 * @ param is the is
 * @ return the list */
private boolean processMultiBulkReply ( ByteBuf in ) { } }

implementation: final int length = lineLength ( ) ; if ( length == 0 ) { return false ; } in . skipBytes ( length ) ; int num = readInt ( length - 2 ) ; if ( num == - 1 ) { return true ; } for ( int i = 0 ; i < num ; i ++ ) { if ( hasFrame ( in ) == false ) { return false ; } } return true ;


signature:
public class RedisDecoder { /** * Process integer .
 * @ param is the is
 * @ return the long */
private boolean processInteger ( ByteBuf in ) { } }

implementation: int length = lineLength ( ) ; if ( length == 0 ) { return false ; } in . skipBytes ( length ) ; return true ;


signature:
public class RedisDecoder { /** * Process bulk reply .
 * @ param is the is
 * @ return the byte [ ] */
private boolean processBulkReply ( ByteBuf in ) { } }

implementation:
int length = lineLength ( ) ; if ( length == 0 ) { return false ; } in . skipBytes ( length ) ; int numBytes = readInt ( length - 2 ) ; // 2 = = \ r \ n
if ( numBytes == - 1 ) { return true ; } if ( in . readableBytes ( ) < numBytes + 2 ) { return false ; } in . skipBytes ( numBytes + 2 ) ; return true ;


signature:
public class RedisDecoder { /** * Process status code reply .
 * @ param is the is
 * @ return the byte [ ] */
private boolean processStatusCodeReply ( ByteBuf in ) { } }


signature:
public class RedisClusterTemplate { /** * @ see RedisClusterOperations # opsForSessionOfHashList ( ) */
public < HK , HV > SessionOfHashListOperations < K , HK , HV > opsForSessionOfHashList ( ) { } }

implementation: return new DefaultSessionOfHashListOperations < K , HK , HV > ( this ) ;


signature:
public class RedisClusterTemplate { /** * @ see RedisClusterOperations # opsForSessionOfHashSet ( ) */
public < HK , HV > SessionOfHashSetOperations < K , HK , HV > opsForSessionOfHashSet ( ) { } }

implementation: return new DefaultSessionOfHashSetOperations < K , HK , HV > ( this ) ;


signature:
public class RedisClusterTemplate { /** * @ see RedisClusterOperations # boundSessionOfHashListOps ( java . lang . Object , java . lang . Object ) */
public < HK , HV > BoundSessionOfHashListOperations < K , HK , HV > boundSessionOfHashListOps ( K key , HK field ) { } }

implementation: return new DefaultBoundSessionOfHashListOperations < K , HK , HV > ( key , field , this ) ;


signature:
public class RedisClusterTemplate { /** * @ see RedisClusterOperations # boundSessionOfHashSetOps ( java . lang . Object , java . lang . Object ) */
public < HK , HV > BoundSessionOfHashSetOperations < K , HK , HV > boundSessionOfHashSetOps ( K key , HK field ) { } }

implementation: return new DefaultBoundSessionOfHashSetOperations < K , HK , HV > ( key , field , this ) ;


signature:
public class MGSetquorum { /** * Since it is a singleton instance and represents a part of workflow logic running in multiple threads . */
public void setquorum ( PartitionGroupServer master , int q , String quorumMembers ) throws MgmtSetquorumException , MgmtSmrCommandException { } }

implementation: master . setQuorum ( q , quorumMembers ) ;


signature:
public class ThreadLocalVariableHolder { /** * Clear ZNodePermission of current - thread to null .
 * If znodePermission . get ( ) returns null , this method skip permission - check . Otherwise , do permission - check .
 * < pre > There are two different scenarios .
 * 1 . workflows , commands , watch - event for clusters do permission - check .
 * 2 . leader - election , confmaster - init / release skip permission - check . < / pre >
 * It is not deterministic that what thread will allocated to the scenarios .
 * Call this method not to affect a next thread , after calling addPermission ( ) method . */
public static void checkPermission ( String path , LockType type ) throws MgmtZooKeeperException { } }

implementation: if ( znodePermission . get ( ) != null ) { znodePermission . get ( ) . checkPermission ( path , type ) ; }


signature:
public class BinaryRedisClusterClient { /** * Join parameters .
 * @ param first the first
 * @ param rest the rest
 * @ return the byte [ ] [ ] */
private byte [ ] [ ] joinParameters ( byte [ ] first , byte [ ] [ ] rest ) { } }

implementation: byte [ ] [ ] result = new byte [ rest . length + 1 ] [ ] ; result [ 0 ] = first ; for ( int i = 0 ; i < rest . length ; i ++ ) { result [ i + 1 ] = rest [ i ] ; } return result ;


signature:
public class BinaryRedisClusterClient { /** * Expire .
 * @ param key the key
 * @ param seconds the seconds */
public void expire ( final byte [ ] key , final int seconds ) { } }

implementation: sendCommand ( Command . EXPIRE , key , RedisProtocol . toByteArray ( seconds ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Expire at .
 * @ param key the key
 * @ param millisecondsTimestamp the unix time */
public void expireAt ( final byte [ ] key , final long millisecondsTimestamp ) { } }

implementation: sendCommand ( Command . EXPIREAT , key , RedisProtocol . toByteArray ( millisecondsTimestamp ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Setex .
 * @ param key the key
 * @ param seconds the seconds
 * @ param value the value */
public void setex ( final byte [ ] key , final int seconds , final byte [ ] value ) { } }

implementation: sendCommand ( Command . SETEX , key , RedisProtocol . toByteArray ( seconds ) , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Decr by .
 * @ param key the key
 * @ param integer the integer */
public void decrBy ( final byte [ ] key , final long integer ) { } }

implementation: sendCommand ( Command . DECRBY , key , RedisProtocol . toByteArray ( integer ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Incr by .
 * @ param key the key
 * @ param integer the integer */
public void incrBy ( final byte [ ] key , final long integer ) { } }

implementation: sendCommand ( Command . INCRBY , key , RedisProtocol . toByteArray ( integer ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Substr .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void substr ( final byte [ ] key , final int start , final int end ) { } }

implementation: sendCommand ( Command . SUBSTR , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Hset .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hset ( final byte [ ] key , final byte [ ] field , final byte [ ] value ) { } }

implementation: sendCommand ( Command . HSET , key , field , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Hsetnx .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hsetnx ( final byte [ ] key , final byte [ ] field , final byte [ ] value ) { } }

implementation: sendCommand ( Command . HSETNX , key , field , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Hmset .
 * @ param key the key
 * @ param hash the hash */
public void hmset ( final byte [ ] key , final Map < byte [ ] , byte [ ] > hash ) { } }

implementation: final List < byte [ ] > params = new ArrayList < byte [ ] > ( ) ; params . add ( key ) ; for ( final Entry < byte [ ] , byte [ ] > entry : hash . entrySet ( ) ) { params . add ( entry . getKey ( ) ) ; params . add ( entry . getValue ( ) ) ; } sendCommand ( Command . HMSET , params . toArray ( new byte [ params . size ( ) ] [ ] ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Hmget .
 * @ param key the key
 * @ param fields the fields */
public void hmget ( final byte [ ] key , final byte [ ] ... fields ) { } }

implementation: final byte [ ] [ ] params = new byte [ fields . length + 1 ] [ ] ; params [ 0 ] = key ; System . arraycopy ( fields , 0 , params , 1 , fields . length ) ; sendCommand ( Command . HMGET , params ) ;


signature:
public class BinaryRedisClusterClient { /** * Hincr by .
 * @ param key the key
 * @ param field the field
 * @ param value the value */
public void hincrBy ( final byte [ ] key , final byte [ ] field , final long value ) { } }

implementation: sendCommand ( Command . HINCRBY , key , field , RedisProtocol . toByteArray ( value ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Lrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void lrange ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . LRANGE , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Ltrim .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void ltrim ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . LTRIM , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Lindex .
 * @ param key the key
 * @ param index the index */
public void lindex ( final byte [ ] key , final long index ) { } }

implementation: sendCommand ( Command . LINDEX , key , RedisProtocol . toByteArray ( index ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Lset .
 * @ param key the key
 * @ param index the index
 * @ param value the value */
public void lset ( final byte [ ] key , final long index , final byte [ ] value ) { } }

implementation: sendCommand ( Command . LSET , key , RedisProtocol . toByteArray ( index ) , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Lrem .
 * @ param key the key
 * @ param count the count
 * @ param value the value */
public void lrem ( final byte [ ] key , long count , final byte [ ] value ) { } }

implementation: sendCommand ( Command . LREM , key , RedisProtocol . toByteArray ( count ) , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Zadd .
 * @ param key the key
 * @ param score the score
 * @ param member the member */
public void zadd ( final byte [ ] key , final double score , final byte [ ] member ) { } }

implementation: sendCommand ( Command . ZADD , key , RedisProtocol . toByteArray ( score ) , member ) ;


signature:
public class BinaryRedisClusterClient { /** * Zadd binary .
 * @ param key the key
 * @ param scoreMembers the score members */
public void zaddBinary ( final byte [ ] key , Map < Double , byte [ ] > scoreMembers ) { } }

implementation: ArrayList < byte [ ] > args = new ArrayList < byte [ ] > ( scoreMembers . size ( ) * 2 + 1 ) ; args . add ( key ) ; for ( Map . Entry < Double , byte [ ] > entry : scoreMembers . entrySet ( ) ) { args . add ( RedisProtocol . toByteArray ( entry . getKey ( ) ) ) ; args . add ( entry . getValue ( ) ) ; } byte [ ] [ ] argsArray = new byte [ args . size ( ) ] [ ] ; args . toArray ( argsArray ) ; sendCommand ( Command . ZADD , argsArray ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrange ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . ZRANGE , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Zincrby .
 * @ param key the key
 * @ param score the score
 * @ param member the member */
public void zincrby ( final byte [ ] key , final double score , final byte [ ] member ) { } }

implementation: sendCommand ( Command . ZINCRBY , key , RedisProtocol . toByteArray ( score ) , member ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrevrange .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrevrange ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . ZREVRANGE , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrange with scores .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrangeWithScores ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . ZRANGE , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) , Keyword . WITHSCORES . raw ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrevrange with scores .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zrevrangeWithScores ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . ZREVRANGE , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) , Keyword . WITHSCORES . raw ) ;


signature:
public class BinaryRedisClusterClient { /** * Zcount .
 * @ param key the key
 * @ param min the min
 * @ param max the max */
public void zcount ( final byte [ ] key , final byte [ ] min , final byte [ ] max ) { } }

implementation: sendCommand ( Command . ZCOUNT , key , min , max ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrange by score .
 * @ param key the key
 * @ param min the min
 * @ param max the max */
public void zrangeByScore ( final byte [ ] key , final byte [ ] min , final byte [ ] max ) { } }

implementation: sendCommand ( Command . ZRANGEBYSCORE , key , min , max ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrevrange by score .
 * @ param key the key
 * @ param max the max
 * @ param min the min */
public void zrevrangeByScore ( final byte [ ] key , final byte [ ] max , final byte [ ] min ) { } }

implementation: sendCommand ( Command . ZREVRANGEBYSCORE , key , max , min ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrevrange by score .
 * @ param key the key
 * @ param max the max
 * @ param min the min
 * @ param offset the offset
 * @ param count the count */
public void zrevrangeByScore ( final byte [ ] key , final byte [ ] max , final byte [ ] min , final int offset , int count ) { } }

implementation: sendCommand ( Command . ZREVRANGEBYSCORE , key , max , min , Keyword . LIMIT . raw , RedisProtocol . toByteArray ( offset ) , RedisProtocol . toByteArray ( count ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrevrange by score with scores .
 * @ param key the key
 * @ param max the max
 * @ param min the min */
public void zrevrangeByScoreWithScores ( final byte [ ] key , final byte [ ] max , final byte [ ] min ) { } }

implementation: sendCommand ( Command . ZREVRANGEBYSCORE , key , max , min , Keyword . WITHSCORES . raw ) ;


signature:
public class BinaryRedisClusterClient { /** * Zrange by score with scores .
 * @ param key the key
 * @ param min the min
 * @ param max the max
 * @ param offset the offset
 * @ param count the count */
public void zrangeByScoreWithScores ( final byte [ ] key , final byte [ ] min , final byte [ ] max , final int offset , final int count ) { } }

implementation: sendCommand ( Command . ZRANGEBYSCORE , key , min , max , Keyword . LIMIT . raw , RedisProtocol . toByteArray ( offset ) , RedisProtocol . toByteArray ( count ) , Keyword . WITHSCORES . raw ) ;


signature:
public class BinaryRedisClusterClient { /** * Zremrange by rank .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zremrangeByRank ( final byte [ ] key , final long start , final long end ) { } }

implementation: sendCommand ( Command . ZREMRANGEBYRANK , key , RedisProtocol . toByteArray ( start ) , RedisProtocol . toByteArray ( end ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Zremrange by score .
 * @ param key the key
 * @ param start the start
 * @ param end the end */
public void zremrangeByScore ( final byte [ ] key , final byte [ ] start , final byte [ ] end ) { } }

implementation: sendCommand ( Command . ZREMRANGEBYSCORE , key , start , end ) ;


signature:
public class BinaryRedisClusterClient { /** * Slaveof no one . */
public void slaveofNoOne ( ) { } }

implementation: sendCommand ( Command . SLAVEOF , Keyword . NO . raw , Keyword . ONE . raw ) ;


signature:
public class BinaryRedisClusterClient { /** * Config set .
 * @ param parameter the parameter
 * @ param value the value */
public void configSet ( final byte [ ] parameter , final byte [ ] value ) { } }

implementation: sendCommand ( Command . CONFIG , Keyword . SET . raw , parameter , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Linsert .
 * @ param key the key
 * @ param where the where
 * @ param pivot the pivot
 * @ param value the value */
public void linsert ( final byte [ ] key , final BinaryClient . LIST_POSITION where , final byte [ ] pivot , final byte [ ] value ) { } }

implementation: sendCommand ( Command . LINSERT , key , where . raw , pivot , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Setbit .
 * @ param key the key
 * @ param offset the offset
 * @ param value the value */
public void setbit ( byte [ ] key , long offset , byte [ ] value ) { } }

implementation: sendCommand ( Command . SETBIT , key , RedisProtocol . toByteArray ( offset ) , value ) ;


signature:
public class BinaryRedisClusterClient { /** * Gets the bit .
 * @ param key the key
 * @ param offset the offset */
public void getbit ( byte [ ] key , long offset ) { } }

implementation: sendCommand ( Command . GETBIT , key , RedisProtocol . toByteArray ( offset ) ) ;


signature:
public class BinaryRedisClusterClient { /** * Setrange .
 * @ param key the key
 * @ param offset the offset
 * @ param value the value */
public void setrange ( byte [ ] key , long offset , byte [ ] value ) { } }

implementation: sendCommand ( Command . SETRANGE , key , RedisProtocol . toByteArray ( offset ) , value ) ;