/*

  * 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.ooc.persistence;

 import java.util.ArrayList;

 import java.util.List;

 /**

  * Index chain used in out-of-core data accessor object (DAO) to access

  * serialized data.

  */

 public class DataIndex {

   /** Chain of data indices */

   private final List<DataIndexEntry> indexList = new ArrayList<>(5);

   /**

    * Add an index to the index chain

    *

    * @param entry the entry to add to the chain

    * @return the index chain itself

    */

   public DataIndex addIndex(DataIndexEntry entry) {

     indexList.add(entry);

     return this;

   }

   /**

    * Remove/Pop the last index in the index chain

    *

    * @return the index chain itself

    */

   public DataIndex removeLastIndex() {

     indexList.remove(indexList.size() - 1);

     return this;

   }

   /**

    * Create a copy of the existing DataIndex

    *

    * @return a copy of the existing index chain

    */

   public DataIndex copy() {

     DataIndex index = new DataIndex();

     for (DataIndexEntry entry : indexList) {

       index.indexList.add(entry);

     }

     return index;

   }

   @Override

   public boolean equals(Object obj) {

     if (!(obj instanceof DataIndex)) {

       return false;

     }

     DataIndex dataIndex = (DataIndex) obj;

     return indexList.equals(dataIndex.indexList);

   }

   @Override

   public int hashCode() {

     return indexList.hashCode();

   }

   @Override

   public String toString() {

     StringBuffer sb = new StringBuffer();

     for (DataIndexEntry entry : indexList) {

       sb.append(entry);

     }

     return sb.toString();

   }

   /** Interface to unify different types of entries used as index chain */

   public interface DataIndexEntry { }

   /**

    * Different static types of index chain entry

    */

   public enum TypeIndexEntry implements DataIndexEntry {

     /** The whole partition */

     PARTITION("_partition"),

     /** Partition vertices */

     PARTITION_VERTICES("_vertices"),

     /** Partition edges */

     PARTITION_EDGES("_edges"),

     /** Partition messages */

     MESSAGE("_messages"),

     /** Edges stored in edge store for a partition */

     EDGE_STORE("_edge_store"),

     /** Raw data buffer (refer to DiskBackedDataStore) */

     BUFFER("_buffer");

     /** String realization of entry type */

     private final String name;

     /**

      * Constructor

      *

      * @param name name of the type

      */

     TypeIndexEntry(String name) {

       this.name = name;

     }

     public String getName() {

       return name;

     }

     @Override

     public String toString() {

       return name;

     }

   }

   /**

    * Class representing any index chain that depends on something with id.

    * Generally this is used for identifying indices in two types:

    *  - Index entry based on superstep id ('S' and the superstep number)

    *  - Index entry based on partition id ('P' and the partition id)

    */

   public static final class NumericIndexEntry implements DataIndexEntry {

     /** Type of index */

     private final char type;

     /** Id of the index associated with the specified type */

     private final long id;

     /**

      * Constructor

      *

      * @param type type of index (for now 'S' for superstep, or 'P' for

      *             partition)

      * @param id id of the index associated with the given type

      */

     private NumericIndexEntry(char type, long id) {

       this.type = type;

       this.id = id;

     }

     @Override

     public boolean equals(Object obj) {

       if (!(obj instanceof NumericIndexEntry)) {

         return false;

       }

       NumericIndexEntry index = (NumericIndexEntry) obj;

       return index.type == type && index.id == id;

     }

     @Override

     public int hashCode() {

       int result = 17;

       result = result * 37 + type;

       result = result * 37 + (int) id;

       result = result * 37 + (int) (id >> 32);

       return result;

     }

     @Override

     public String toString() {

       return String.format("_%c%d", type, id);

     }

     /**

      * Create a data index entry for a given partition

      *

      * @param partitionId id of the partition

      * @return data index entry for a given partition

      */

     public static NumericIndexEntry createPartitionEntry(int partitionId) {

       return new NumericIndexEntry('P', partitionId);

     }

     /**

      * Create a data index entry for a given superstep

      *

      * @param superstep the superstep number

      * @return data index entry for a given superstep

      */

     public static NumericIndexEntry createSuperstepEntry(long superstep) {

       return new NumericIndexEntry('S', superstep);

     }

   }

 }