Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.twitter.finagle.memcached.java;
  
  import java.util.List;
  import java.util.Map;
  
  import scala.Option;
  import scala.Tuple2;
  
 
 
 public class ClientBase extends Client {
 
   public ClientBase(com.twitter.finagle.memcached.Client underlying) {
     this. = underlying;
   }
 
   public Future<ChannelBufferget(String key) {
     Future<Option<ChannelBuffer>> result = .get(key);
     return result.map(new Function<Option<ChannelBuffer>, ChannelBuffer>() {
       public ChannelBuffer apply(Option<ChannelBuffervalue) {
         if (value.isDefined()) {
           return (ChannelBuffer)value.get();
         } else {
           return null;
         }
       }
     });
   }
 
   public Future<ResultWithCASgets(String key) {
     return result.map(new Function<Option<Tuple2<ChannelBufferChannelBuffer>>, ResultWithCAS>() {
       public ResultWithCAS apply(Option<Tuple2<ChannelBufferChannelBuffer>> value) {
         if (value.isDefined()) {
           return new ResultWithCAS(value.get()._1(), value.get()._2());
         } else {
           return null;
         }
       }
     });
   }
 
   public Future<Map<StringChannelBuffer>> get(List<Stringkeys) {
       .get(JavaConversions.asScalaBuffer(keys));
     return result.map(new Function<scala.collection.immutable.Map<StringChannelBuffer>, Map<StringChannelBuffer>>() {
       public Map<StringChannelBufferapply(scala.collection.immutable.Map<StringChannelBufferunderlying) {
         return JavaConversions.asJavaMap(underlying);
       }
     });
   }
 
   public Future<Map<StringResultWithCAS>> gets(List<Stringkeys) {
       .gets(JavaConversions.asScalaBuffer(keys));
     return result.map(new Function<
       Map<StringResultWithCAS>>() {
       public Map<StringResultWithCASapply(
       {
         return JavaConversions.asJavaMap(
           underlying.mapValues(new Function<Tuple2<ChannelBufferChannelBuffer>, ResultWithCAS>() {
             public ResultWithCAS apply(Tuple2<ChannelBufferChannelBuffertuple) {
               return new ResultWithCAS(tuple._1(), tuple._2());
             }
           })
         );
       }
     });
   }
 
   public Future<GetResultgetResult(List<Stringkeys) {
     return .getResult(JavaConversions.asScalaBuffer(keys));
   }
 
   public Future<GetsResultgetsResult(List<Stringkeys) {
     return .getsResult(JavaConversions.asScalaBuffer(keys));
   }
 
   public Future<Voidset(String keyChannelBuffer value) {
     Future<scala.runtime.BoxedUnitresult = .set(keyvalue);
     return result.map(new Function<scala.runtime.BoxedUnitVoid>() {
       public Void apply(scala.runtime.BoxedUnit obj) {
         return null;
       }
     });
   }
 
   public Future<Voidset(String keyint flagsTime expiryChannelBuffer value) {
     Future<scala.runtime.BoxedUnitresult = .set(keyflagsexpiryvalue);
    return result.map(new Function<scala.runtime.BoxedUnitVoid>() {
      public Void apply(scala.runtime.BoxedUnit obj) {
        return null;
      }
    });
  }
  public Future<Booleanadd(String keyChannelBuffer value) {
    return .add(keyvalue);
  }
  public Future<Booleanadd(String keyint flagsTime expiryChannelBuffer value) {
    return .add(keyflagsexpiryvalue);
  }
  public Future<Booleanappend(String keyChannelBuffer value) {
    return .append(keyvalue);
  }
  public Future<Booleanprepend(String keyChannelBuffer value) {
    return .prepend(keyvalue);
  }
  public Future<Booleanreplace(String keyChannelBuffer value) {
    return .replace(keyvalue);
  }
  public Future<Booleanreplace(String keyint flagsTime expiryChannelBuffer value) {
    return .replace(keyflagsexpiryvalue);
  }
  public Future<Booleancas(String keyChannelBuffer valueChannelBuffer casUnique) {
    return .cas(keyvaluecasUnique);
  }
  public Future<Booleancas(
    String keyint flagsTime expiry,
    ChannelBuffer valueChannelBuffer casUnique) {
    return .cas(keyflagsexpiryvaluecasUnique);
  }
  public Future<Booleandelete(String key) {
    return .delete(key);
  }
  public Future<Longincr(String key) {
    Future<Option<Long>> result = .incr(key);
    return result.map(new Function<Option<Long>, Long>() {
      public Long apply(Option<Longvalue) {
        if (value.isDefined()) {
          return (Longvalue.get();
        } else {
          return -1L;
        }
      }
    });
  }
  public Future<Longincr(String keylong delta) {
    Future<Option<Long>> result = .incr(keydelta);
    return result.map(new Function<Option<Long>, Long>() {
      public Long apply(Option<Longvalue) {
        if (value.isDefined()) {
          return (Longvalue.get();
        } else {
          return -1L;
        }
      }
    });
  }
  public Future<Longdecr(String key) {
    Future<Option<Long>> result = .decr(key);
    return result.map(new Function<Option<Long>, Long>() {
      public Long apply(Option<Longvalue) {
        if (value.isDefined()) {
          return (Longvalue.get();
        } else {
          return -1L;
        }
      }
    });
  }
  public Future<Longdecr(String keylong delta) {
    Future<Option<Long>> result = .decr(keydelta);
    return result.map(new Function<Option<Long>, Long>() {
      public Long apply(Option<Longvalue) {
        if (value.isDefined()) {
          return (Longvalue.get();
        } else {
          return -1L;
        }
      }
    });
  }
  public void release() {
  }
New to GrepCode? Check out our FAQ X