All Downloads are FREE. Search and download functionalities are using the official Maven repository.

mssql.googlecode.concurrentlinkedhashmap.Weighers Maven / Gradle / Ivy

Go to download

Microsoft JDBC Driver for SQL Server. The Azure Key Vault feature in Microsoft JDBC Driver for SQL Server depends on Azure SDK for JAVA and Azure Active Directory Library For Java.

There is a newer version: 12.7.0.jre11-preview
Show newest version
/*
 * Copyright 2010 Google Inc. All Rights Reserved.
 *
 * 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 mssql.googlecode.concurrentlinkedhashmap;

import static mssql.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap.checkNotNull;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A common set of {@link Weigher} and {@link EntryWeigher} implementations.
 *
 * @author [email protected] (Ben Manes)
 * @see 
 *      http://code.google.com/p/concurrentlinkedhashmap/
 */
public final class Weighers {

  private Weighers() {
    throw new AssertionError();
  }

  /**
   * A entry weigher backed by the specified weigher. The weight of the value
   * determines the weight of the entry.
   *
   * @param  K
   * @param  V
   * @param weigher the weigher to be "wrapped" in a entry weigher.
   * @return A entry weigher view of the specified weigher.
   */
  public static  EntryWeigher asEntryWeigher(
      final Weigher weigher) {
    return (weigher == singleton())
        ? Weighers.entrySingleton()
        : new EntryWeigherView(weigher);
  }

  /**
   * A weigher where an entry has a weight of 1. A map bounded with
   * this weigher will evict when the number of key-value pairs exceeds the
   * capacity.
   *
   * @param  K
   * @param  V
   * @return A weigher where a value takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  EntryWeigher entrySingleton() {
    return (EntryWeigher) SingletonEntryWeigher.INSTANCE;
  }

  /**
   * A weigher where a value has a weight of 1. A map bounded with
   * this weigher will evict when the number of key-value pairs exceeds the
   * capacity.
   *
   * @param  V
   * @return A weigher where a value takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher singleton() {
    return (Weigher) SingletonWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a byte array and its weight is the number of
   * bytes. A map bounded with this weigher will evict when the number of bytes
   * exceeds the capacity rather than the number of key-value pairs in the map.
   * This allows for restricting the capacity based on the memory-consumption
   * and is primarily for usage by dedicated caching servers that hold the
   * serialized data.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   *
   * @return A weigher where each byte takes one unit of capacity.
   */
  public static Weigher byteArray() {
    return ByteArrayWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a {@link Iterable} and its weight is the
   * number of elements. This weigher only should be used when the alternative
   * {@link #collection()} weigher cannot be, as evaluation takes O(n) time. A
   * map bounded with this weigher will evict when the total number of elements
   * exceeds the capacity rather than the number of key-value pairs in the map.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   * 
   * @param  E
   * @return A weigher where each element takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher> iterable() {
    return (Weigher>) (Weigher) IterableWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a {@link Collection} and its weight is the
   * number of elements. A map bounded with this weigher will evict when the
   * total number of elements exceeds the capacity rather than the number of
   * key-value pairs in the map.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   *
   * @param  E
   * @return A weigher where each element takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher> collection() {
    return (Weigher>) (Weigher) CollectionWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a {@link List} and its weight is the number
   * of elements. A map bounded with this weigher will evict when the total
   * number of elements exceeds the capacity rather than the number of
   * key-value pairs in the map.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   *
   * @param  E
   * @return A weigher where each element takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher> list() {
    return (Weigher>) (Weigher) ListWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a {@link Set} and its weight is the number
   * of elements. A map bounded with this weigher will evict when the total
   * number of elements exceeds the capacity rather than the number of
   * key-value pairs in the map.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   *
   * @param  E
   * @return A weigher where each element takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher> set() {
    return (Weigher>) (Weigher) SetWeigher.INSTANCE;
  }

  /**
   * A weigher where the value is a {@link Map} and its weight is the number of
   * entries. A map bounded with this weigher will evict when the total number of
   * entries across all values exceeds the capacity rather than the number of
   * key-value pairs in the map.
   * 

   * A value with a weight of 0 will be rejected by the map. If a value
   * with this weight can occur then the caller should eagerly evaluate the
   * value and treat it as a removal operation. Alternatively, a custom weigher
   * may be specified on the map to assign an empty value a positive weight.
   *
   * @param  A
   * @param  B
   * @return A weigher where each entry takes one unit of capacity.
   */
  @SuppressWarnings({"cast", "unchecked"})
  public static  Weigher> map() {
    return (Weigher>) (Weigher) MapWeigher.INSTANCE;
  }

  static final class EntryWeigherView implements EntryWeigher, Serializable {
    static final long serialVersionUID = 1;
    final Weigher weigher;

    EntryWeigherView(Weigher weigher) {
      checkNotNull(weigher);
      this.weigher = weigher;
    }

    @Override
    public int weightOf(K key, V value) {
      return weigher.weightOf(value);
    }
  }

  enum SingletonEntryWeigher implements EntryWeigher {
    INSTANCE;

    @Override
    public int weightOf(Object key, Object value) {
      return 1;
    }
  }

  enum SingletonWeigher implements Weigher {
    INSTANCE;

    @Override
    public int weightOf(Object value) {
      return 1;
    }
  }

  enum ByteArrayWeigher implements Weigher {
    INSTANCE;

    @Override
    public int weightOf(byte[] value) {
      return value.length;
    }
  }

  enum IterableWeigher implements Weigher> {
    INSTANCE;

    @Override
    public int weightOf(Iterable values) {
      if (values instanceof Collection) {
        return ((Collection) values).size();
      }
      int size = 0;
      for (Iterator i = values.iterator(); i.hasNext();) {
        i.next();
        size++;
      }
      return size;
    }
  }

  enum CollectionWeigher implements Weigher> {
    INSTANCE;

    @Override
    public int weightOf(Collection values) {
      return values.size();
    }
  }

  enum ListWeigher implements Weigher> {
    INSTANCE;

    @Override
    public int weightOf(List values) {
      return values.size();
    }
  }

  enum SetWeigher implements Weigher> {
    INSTANCE;

    @Override
    public int weightOf(Set values) {
      return values.size();
    }
  }

  enum MapWeigher implements Weigher> {
    INSTANCE;

    @Override
    public int weightOf(Map values) {
      return values.size();
    }
  }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy