    001    /*
    002     * Copyright (c) 2007-2014 Concurrent, Inc. All Rights Reserved.
    003     *
    004     * Project and contact information: http://www.cascading.org/
    005     *
    006     * This file is part of the Cascading project.
    007     *
    008     * Licensed under the Apache License, Version 2.0 (the "License");
    009     * you may not use this file except in compliance with the License.
    010     * You may obtain a copy of the License at
    011     *
    012     *     http://www.apache.org/licenses/LICENSE-2.0
    013     *
    014     * Unless required by applicable law or agreed to in writing, software
    015     * distributed under the License is distributed on an "AS IS" BASIS,
    016     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    017     * See the License for the specific language governing permissions and
    018     * limitations under the License.
    019     */
    020
    021    package cascading.tuple.io;
    022
    023    import java.util.Arrays;
    024    import java.util.List;
    025
    026    import cascading.tuple.Tuple;
    027
    028    /**
    029     * Class TuplePair is a utility class that is optimized to hold two Tuple instances for sorting and hashing of each
    030     * part independently.
    031     */
    032    public class TuplePair extends Tuple
    033      {
    034      /** Field tuples */
    035      private final Tuple[] tuples = new Tuple[ 2 ];
    036
    037      /**
    038       * Returns a reference to the private tuples of the given TuplePark
    039       *
    040       * @param tuplePair of type Tuple[]
    041       * @return Tuple[]
    042       */
    043      static Tuple[] tuples( TuplePair tuplePair )
    044        {
    045        return tuplePair.tuples;
    046        }
    047
    048      /** Constructor Tuple creates a new Tuple instance. */
    049      public TuplePair()
    050        {
    051        super( (List<Object>) null ); // bypass unnecessary List creation
    052        tuples[ 0 ] = new Tuple();
    053        tuples[ 1 ] = new Tuple();
    054        }
    055
    056      /**
    057       * Constructor TuplePair creates a new TuplePair instance.
    058       *
    059       * @param lhs of type Tuple
    060       * @param rhs of type Tuple
    061       */
    062      public TuplePair( Tuple lhs, Tuple rhs )
    063        {
    064        super( (List<Object>) null ); // bypass unnecessary List creation
    065        tuples[ 0 ] = lhs;
    066        tuples[ 1 ] = rhs;
    067
    068        if( lhs == null )
    069          throw new IllegalArgumentException( "lhs may not be null" );
    070
    071        if( rhs == null )
    072          throw new IllegalArgumentException( "rhs may not be null" );
    073        }
    074
    075      /**
    076       * Method getLhs returns the lhs of this TuplePair object.
    077       *
    078       * @return the lhs (type Tuple) of this TuplePair object.
    079       */
    080      public Tuple getLhs()
    081        {
    082        return tuples[ 0 ];
    083        }
    084
    085      /**
    086       * Method getRhs returns the rhs of this TuplePair object.
    087       *
    088       * @return the rhs (type Tuple) of this TuplePair object.
    089       */
    090      public Tuple getRhs()
    091        {
    092        return tuples[ 1 ];
    093        }
    094
    095      @Override
    096      public boolean equals( Object object )
    097        {
    098        if( this == object )
    099          return true;
    100        if( object == null || getClass() != object.getClass() )
    101          return false;
    102
    103        TuplePair tuplePair = (TuplePair) object;
    104
    105        if( !Arrays.equals( tuples, tuplePair.tuples ) )
    106          return false;
    107
    108        return true;
    109        }
    110
    111      @Override
    112      public int hashCode()
    113        {
    114        return Arrays.hashCode( tuples );
    115        }
    116
    117      @Override
    118      public int compareTo( Object other )
    119        {
    120        if( other instanceof TuplePair )
    121          return compareTo( (TuplePair) other );
    122        else
    123          return -1;
    124        }
    125
    126      @Override
    127      public int compareTo( Tuple other )
    128        {
    129        if( other instanceof TuplePair )
    130          return compareTo( (TuplePair) other );
    131        else
    132          return -1;
    133        }
    134
    135      /**
    136       * Method compareTo compares this instance to the given TuplePair.
    137       *
    138       * @param tuplePair of type TuplePair
    139       * @return int
    140       */
    141      public int compareTo( TuplePair tuplePair )
    142        {
    143        int c = tuples[ 0 ].compareTo( tuplePair.tuples[ 0 ] );
    144
    145        if( c != 0 )
    146          return c;
    147
    148        c = tuples[ 1 ].compareTo( tuplePair.tuples[ 1 ] );
    149
    150        return c;
    151        }
    152
    153      @Override
    154      public String toString()
    155        {
    156        return tuples[ 0 ].print() + tuples[ 1 ].print();
    157        }
    158
    159      @Override
    160      public String print()
    161        {
    162        return tuples[ 0 ].print() + tuples[ 1 ].print();
    163        }
    164      }