Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   * in compliance with the License. You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 
 package com.google.common.hash;
 
 
 
 import  javax.annotation.Nullable;

Funnels for common types. All implementations are serializable.

Author(s):
Dimitris Andreou
Since:
11.0
 
 public final class Funnels {
   private Funnels() {}

  
Returns a funnel that extracts the bytes from a byte array.
 
   public static Funnel<byte[]> byteArrayFunnel() {
     return .;
   }
 
   private enum ByteArrayFunnel implements Funnel<byte[]> {
     INSTANCE;
 
     public void funnel(byte[] fromPrimitiveSink into) {
       into.putBytes(from);
     }
 
     @Override public String toString() {
       return "Funnels.byteArrayFunnel()";
     }
   }

  
Returns a funnel that extracts the characters from a CharSequence, a character at a time, without performing any encoding. If you need to use a specific encoding, use Funnels.stringFunnel(Charset) instead.

Since:
15.0 (since 11.0 as Funnels.stringFunnel().
 
   public static Funnel<CharSequenceunencodedCharsFunnel() {
     return .;
   }

  
Returns a funnel that extracts the characters from a CharSequence.

Deprecated:
Use Funnels.unencodedCharsFunnel instead. This method is scheduled for removal in Guava 16.0.
 
   public static Funnel<CharSequencestringFunnel() {
     return unencodedCharsFunnel();
   }
 
   private enum UnencodedCharsFunnel implements Funnel<CharSequence> {
     INSTANCE;
 
     public void funnel(CharSequence fromPrimitiveSink into) {
       into.putUnencodedChars(from);
     }
 
     @Override public String toString() {
       return "Funnels.unencodedCharsFunnel()";
     }
   }

  
Returns a funnel that encodes the characters of a CharSequence with the specified Charset.

Since:
15.0
 
   public static Funnel<CharSequencestringFunnel(Charset charset) {
     return new StringCharsetFunnel(charset);
   }
 
   private static class StringCharsetFunnel implements Funnel<CharSequence>, Serializable {
    private final Charset charset;
    StringCharsetFunnel(Charset charset) {
      this. = Preconditions.checkNotNull(charset);
    }
    public void funnel(CharSequence fromPrimitiveSink into) {
      into.putString(from);
    }
    @Override public String toString() {
      return "Funnels.stringFunnel(" + .name() + ")";
    }
    @Override public boolean equals(@Nullable Object o) {
      if (o instanceof StringCharsetFunnel) {
        StringCharsetFunnel funnel = (StringCharsetFunnelo;
        return this..equals(funnel.charset);
      }
      return false;
    }
    @Override public int hashCode() {
      return StringCharsetFunnel.class.hashCode() ^ .hashCode();
    }
    Object writeReplace() {
      return new SerializedForm();
    }
    private static class SerializedForm implements Serializable {
      private final String charsetCanonicalName;
      SerializedForm(Charset charset) {
        this. = charset.name();
      }
      private Object readResolve() {
        return stringFunnel(Charset.forName());
      }
      private static final long serialVersionUID = 0;
    }
  }

  
Returns a funnel for integers.

Since:
13.0
  public static Funnel<IntegerintegerFunnel() {
    return .;
  }
  private enum IntegerFunnel implements Funnel<Integer> {
    INSTANCE;
    public void funnel(Integer fromPrimitiveSink into) {
      into.putInt(from);
    }
    @Override public String toString() {
      return "Funnels.integerFunnel()";
    }
  }

  
Returns a funnel that processes an Iterable by funneling its elements in iteration order with the specified funnel. No separators are added between the elements.

Since:
15.0
  public static <E> Funnel<Iterable<? extends E>> sequentialFunnel(Funnel<E> elementFunnel) {
    return new SequentialFunnel<E>(elementFunnel);
  }
  private static class SequentialFunnel<E> implements Funnel<Iterable<? extends E>>, Serializable {
    private final Funnel<E> elementFunnel;
    SequentialFunnel(Funnel<E> elementFunnel) {
      this. = Preconditions.checkNotNull(elementFunnel);
    }
    public void funnel(Iterable<? extends E> fromPrimitiveSink into) {
      for (E e : from) {
        .funnel(einto);
      }
    }
    @Override public String toString() {
      return "Funnels.sequentialFunnel(" +  + ")";
    }
    @Override public boolean equals(@Nullable Object o) {
      if (o instanceof SequentialFunnel) {
        SequentialFunnel<?> funnel = (SequentialFunnel<?>) o;
        return .equals(funnel.elementFunnel);
      }
      return false;
    }
    @Override public int hashCode() {
      return SequentialFunnel.class.hashCode() ^ .hashCode();
    }
  }

  
Returns a funnel for longs.

Since:
13.0
  public static Funnel<LonglongFunnel() {
    return .;
  }
  private enum LongFunnel implements Funnel<Long> {
    INSTANCE;
    public void funnel(Long fromPrimitiveSink into) {
      into.putLong(from);
    }
    @Override public String toString() {
      return "Funnels.longFunnel()";
    }
  }

  
Wraps a PrimitiveSink as an OutputStream, so it is easy to funnel an object to a PrimitiveSink if there is already a way to write the contents of the object to an OutputStream.

The close and flush methods of the returned OutputStream do nothing, and no method throws IOException.

Since:
13.0
  public static OutputStream asOutputStream(PrimitiveSink sink) {
    return new SinkAsStream(sink);
  }
  private static class SinkAsStream extends OutputStream {
    final PrimitiveSink sink;
    SinkAsStream(PrimitiveSink sink) {
      this. = Preconditions.checkNotNull(sink);
    }
    @Override public void write(int b) {
      .putByte((byteb);
    }
    @Override public void write(byte[] bytes) {
      .putBytes(bytes);
    }
    @Override public void write(byte[] bytesint offint len) {
      .putBytes(bytesofflen);
    }
    @Override public String toString() {
      return "Funnels.asOutputStream(" +  + ")";
    }
  }
New to GrepCode? Check out our FAQ X