giraph-core/templates/WTypeArrayList.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.giraph.types.ops.collections.array;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Arrays;

import org.apache.giraph.function.Consumer;
import org.apache.giraph.function.Predicate;
import org.apache.giraph.function.primitive.${type.camel}Consumer;
import org.apache.giraph.function.primitive.${type.camel}Predicate;
import org.apache.giraph.types.ops.${type.camel}TypeOps;
import org.apache.giraph.types.ops.PrimitiveTypeOps;
import org.apache.giraph.types.ops.collections.ResettableIterator;
import org.apache.giraph.types.ops.collections.W${type.camel}Collection;
import org.apache.hadoop.io.${type.camel}Writable;
import org.apache.giraph.utils.Varint;

import it.unimi.dsi.fastutil.${type.lower}s.${type.camel}ArrayList;
import it.unimi.dsi.fastutil.${type.lower}s.${type.camel}Arrays;
import it.unimi.dsi.fastutil.${type.lower}s.${type.camel}Collection;
import it.unimi.dsi.fastutil.${type.lower}s.${type.camel}List;

${generated_message}

/**
 * Writable extension of ${type.camel}ArrayList, as well as
 * ${type.camel}Writable implementation of WArrayList.
 */
public class W${type.camel}ArrayList
    extends ${type.camel}ArrayList
    implements WArrayList<${type.camel}Writable>, W${type.camel}Collection {
  /**
   * Creates a new array list with {@link #DEFAULT_INITIAL_CAPACITY} capacity.
   */
  public W${type.camel}ArrayList() {
    super();
  }

  /**
   * Creates a new array list with given capacity.
   *
   * @param capacity the initial capacity of the array list (may be 0).
   */
  public W${type.camel}ArrayList(int capacity) {
    super(capacity);
  }

  /**
   * Creates a new array list and fills it with a given type-specific
   * collection.
   *
   * @param c a type-specific collection that will be used to fill the array
   *          list.
   */
  public W${type.camel}ArrayList(${type.camel}Collection c) {
    super(c);
  }

  /**
   * Creates a new array list and fills it with a given type-specific list.
   *
   * @param l a type-specific list that will be used to fill the array list.
   */
  public W${type.camel}ArrayList(${type.camel}List l) {
    super(l);
  }

  @Override
  public PrimitiveTypeOps<${type.camel}Writable> getElementTypeOps() {
    return ${type.camel}TypeOps.INSTANCE;
  }

  @Override
  public int capacity() {
    return elements().length;
  }

  @Override
  public void setCapacity(int n) {
    if (n >= capacity()) {
      ensureCapacity(n);
    } else {
      trim(n);
    }
  }

  @Override
  public void addW(${type.camel}Writable value) {
    add(value.get());
  }

  @Override
  public void getIntoW(int index, ${type.camel}Writable to) {
    to.set(get${type.camel}(index));
  }

  @Override
  public void popIntoW(${type.camel}Writable to) {
    to.set(pop${type.camel}());
  }

  @Override
  public void setW(int index, ${type.camel}Writable value) {
    set(index, value.get());
  }

  @Override
  public void fillW(int from, int to, ${type.camel}Writable value) {
    if (to > size()) {
      throw new ArrayIndexOutOfBoundsException(
          "End index (" + to + ") is greater than array length (" +
              size() + ")");
    }
    Arrays.fill(elements(), from, to, value.get());
  }

  @Override
  public ResettableIterator<${type.camel}Writable> fastIteratorW() {
    return fastIteratorW(getElementTypeOps().create());
  }

  @Override
  public ResettableIterator<${type.camel}Writable> fastIteratorW(
      ${type.camel}Writable iterationValue) {
    return WArrayListPrivateUtils.fastIterator(this, iterationValue);
  }

  @Override
  public void fastForEachW(Consumer<${type.camel}Writable> f) {
    WArrayListPrivateUtils.fastForEach(this, f, getElementTypeOps().create());
  }

  @Override
  public boolean fastForEachWhileW(Predicate<${type.camel}Writable> f) {
    return WArrayListPrivateUtils.fastForEachWhile(
        this, f, getElementTypeOps().create());
  }

  /**
   * Traverse all elements of the array list, calling given function on each
   * element, or until predicate returns false.
   *
   * @param f Function to call on each element.
   */
  public void forEach${type.camel}(${type.camel}Consumer f) {
    for (int i = 0; i < size(); ++i) {
      f.apply(get${type.camel}(i));
    }
  }

  /**
   * Traverse all elements of the array list, calling given function on each
   * element.
   *
   * @param f Function to call on each element.
   * @return true if the predicate returned true for all elements,
   *    false if it returned false for some element.
   */
  public boolean forEachWhile${type.camel}(${type.camel}Predicate f) {
    for (int i = 0; i < size(); ++i) {
      if (!f.apply(get${type.camel}(i))) {
        return false;
      }
    }
    return true;
  }

  @Override
  public void sort() {
    ${type.camel}Arrays.quickSort(elements(), 0, size());
  }

  @Override
  public void writeElements(DataOutput out) throws IOException {
    for (int i = 0; i < size; i++) {
      out.write${type.camel}(a[i]);
    }
  }

  @Override
  public void write(DataOutput out) throws IOException {
    Varint.writeUnsignedVarInt(size, out);
    writeElements(out);
  }

  @Override
  public void readElements(DataInput in, int size) throws IOException {
    this.size = size;
    resizeArrayForRead(size);
    for (int i = 0; i < size; i++) {
      a[i] = in.read${type.camel}();
    }
  }

  /**
   * Resize array for reading given number of elements.
   * @param size Number of elements that will be read.
   */
  protected void resizeArrayForRead(int size) {
    if (size != a.length) {
      a = new ${type.lower}[size];
    }
  }

  @Override
  public void readFields(DataInput in) throws IOException {
    readElements(in, Varint.readUnsignedVarInt(in));
  }

  /**
   * Write a potentially null list to a DataOutput. Null list is written
   * equivalently as an empty list. Use WritableUtils.writeIfNotNullAndObject
   * if distinction is needed.
   *
   * @param list Array list to be written
   * @param out Data output
   */
  public static void writeOrNull(W${type.camel}ArrayList list, DataOutput out)
      throws IOException {
    if (list == null) {
      Varint.writeUnsignedVarInt(0, out);
    } else {
      list.write(out);
    }
  }

  /**
   * Read array list from the DataInput stream into a newly created object.
   *
   * @param in Data input
   * @return New read array list object.
   */
  public static W${type.camel}ArrayList readNew(DataInput in) throws IOException {
    int size = Varint.readSignedVarInt(in);
    W${type.camel}ArrayList list = new W${type.camel}ArrayList(size);
    list.readElements(in, size);
    return list;
  }

  /**
   * Variant of W${type.camel}ArrayList that doesn't reallocate smaller backing
   * array on consecutive readFields/readElements calls, and so is suitable for
   * reusable use.
   * (and backing array will only grow on readFields/readElements calls)
   */
  public static class WReusable${type.camel}ArrayList
      extends W${type.camel}ArrayList {
    /** Constructor */
    public WReusable${type.camel}ArrayList() {
      super();
    }

    /**
     * Constructor
     * @param capacity Capacity
     */
    public WReusable${type.camel}ArrayList(int capacity) {
      super(capacity);
    }

    @Override
    protected void resizeArrayForRead(int size) {
      if (size > a.length) {
        a = new ${type.lower}[size];
      }
    }

    /**
     * Read array list from DataInput stream, into a given list if not null,
     * or creating a new list if given list is null.
     *
     * @param list Array list to be written
     * @param in Data input
     * @return Passed array list, or a new one if null is passed
     */
    public static WReusable${type.camel}ArrayList readIntoOrCreate(
        WReusable${type.camel}ArrayList list, DataInput in) throws IOException {
      int size = Varint.readUnsignedVarInt(in);
      if (list == null) {
        list = new WReusable${type.camel}ArrayList(size);
      }
      list.readElements(in, size);
      return list;
    }
  }
}