001/*
002 * Copyright (c) 2007-2015 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
021package cascading.tuple.io;
022
023import java.util.Arrays;
024import java.util.List;
025
026import 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 */
032public 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  }