Triple

java.lang.Object
- Triple

All Implemented Interfaces:

Hex, java.io.Serializable
```
public class Triple
extends java.lang.Object
implements Hex, java.io.Serializable
```
Three Yarns that all intesect each other. Any one of these Yarns intersects the other two consecutively, with no other Yarn intersections (Joins) between. This corresponds to a trio of rhombs, all of which share a common point and any two of which share a common edge. The union of three such rhombs is a hexagon, and that hexagon can be flipped by reversing the order of all pairs of Yarn intersections. We do not check for these properties on construction; we merely assume that they are satisfied.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

Join[] j
The three Joins.

static long serialVersionUID
For serialization.

Fields
Modifier and Type	Field and Description
`Join[]`	`j` The three Joins.
`static long`	`serialVersionUID` For serialization.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`contains(Rhomb jj)` Determine if this contains a given Rhomb.
`boolean`	`contains(Yarn yy)` Determine if this contains a given Yarn.
`boolean`	`contains(Yarn yy, Yarn z)` Determine if this contains a given pair of Yarns (order doesn't matter).
`SimpleHex`	`createSimpleHex(java.util.List<Rhomb> allJoins, java.util.List<Rhomb> newJoins)` Pass in a list of Joins that contains the three Joins in this Triple.
`static Triple`	`createTriple(Yarn[] yy)` Public static factory method.
`static Triple`	`createTriple(Yarn y0, Yarn y1, Yarn y2)` Public static factory method.
`boolean`	`doubleOverlap(Triple t)` Determine if this contains two Yarns in common with another Triple.
`boolean`	`equals(java.lang.Object obj)` Two Triples are equal if they contain the same three Yarns.
`java.util.List<Hex>`	`flip()` Flip the Yarns in this Triple.
`SimplePolygon2D`	`getHex()` Getter method.
`Rhomb[]`	`getJoins()` Getter method.
`Yarn[]`	`getYarns()` Getter method.
`java.util.List<Triple>`	`newTriples()` Suppose this Triple has just been flipped.
`boolean`	`valid()` Determine if this represents a hexagon--i.e., if the three Yarns still satisfy the adjacency conditions.

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - serialVersionUID
```
public static final long serialVersionUID
```
    For serialization.
    
    See Also:
    Constant Field Values
  - j
```
public Join[] j
```
    The three Joins.
- Method Detail
  - createTriple
```
public static Triple createTriple(Yarn y0,
                  Yarn y1,
                  Yarn y2)
```
    Public static factory method. The three Yarns are assumed to Join each other, with no other Yarns in between Joins. This property is not enforced.
    
    Parameters:
    y0 - The first Yarn.
    y1 - The second Yarn.
    y2 - The third Yarn.
  - createTriple
```
public static Triple createTriple(Yarn[] yy)
```
    Public static factory method. Create a Triple from an array of three Yarns. We don't check to make sure the array is the right length, or the Yarns have the right adjacency properties.
    
    Parameters:
    yy - The array of three Yarns from which we build a Triple.
  - getJoins
```
public Rhomb[] getJoins()
```
    Getter method.
    
    Specified by:
    
    getJoins in interface Hex
    
    Returns:
    A list of the three Joins between the three Yarns.
  - getYarns
```
public Yarn[] getYarns()
```
    Getter method. I hope to remove this soon.
    
    Returns:
    A list of the three Yarns that constitute this Triple.
  - getHex
```
public SimplePolygon2D getHex()
```
    Getter method.
    
    Specified by:
    
    getHex in interface Hex
    
    Returns:
    A polygon equal to the union of the three rhombs represented by the three Joins.
  - valid
```
public boolean valid()
```
    Determine if this represents a hexagon--i.e., if the three Yarns still satisfy the adjacency conditions.
    
    Specified by:
    
    valid in interface Hex
    
    Returns:
    true if the three Yarns satisfy the adjacency conditions, false otherwise.
  - contains
```
public boolean contains(Rhomb jj)
```
    Determine if this contains a given Rhomb. This only contains Joins, so any other type of Rhomb will return false.
    
    Specified by:
    
    contains in interface Hex
    
    Parameters:
    jj - The Rhomb we're looking for.
    
    Returns:
    true if this contains jj, false otherwise.
  - contains
```
public boolean contains(Yarn yy)
```
    Determine if this contains a given Yarn.
    
    Parameters:
    yy - The Yarn we're looking for.
    
    Returns:
    true if this contains yy, false otherwise.
  - contains
```
public boolean contains(Yarn yy,
               Yarn z)
```
    Determine if this contains a given pair of Yarns (order doesn't matter).
    
    Parameters:
    yy - The first Yarn we're looking for.
    z - The second Yarn we're looking for.
    
    Returns:
    true if this contains yy and z, false otherwise.
  - doubleOverlap
```
public boolean doubleOverlap(Triple t)
```
    Determine if this contains two Yarns in common with another Triple.
    
    Parameters:
    t - The other Triple.
    
    Returns:
    true if this contains two Yarns that t also contains.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Two Triples are equal if they contain the same three Yarns.
    
    Overrides:
    
    equals in class java.lang.Object
  - createSimpleHex
```
public SimpleHex createSimpleHex(java.util.List<Rhomb> allJoins,
                        java.util.List<Rhomb> newJoins)
```
    Pass in a list of Joins that contains the three Joins in this Triple. Then create a SimpleHex out of the three SimpleRhombs at the corresponding positions in a list of SimpleRhombs.
    
    Specified by:
    
    createSimpleHex in interface Hex
    
    Parameters:
    allJoins - A list of joins that contains the three Joins that constitute this hex.
    newJoins - A list of SimpleRhombs that correspond to the Joins in allJoins.
    
    Returns:
    A SimpleHex made from the three SimpleRhombs in newJoins that lie at the same indices as the Joins in this lie in allJoins.
  - newTriples
```
public java.util.List<Triple> newTriples()
```
    Suppose this Triple has just been flipped. Create a list of new Triples that are created as a result.
    
    Returns:
    A list of Triples that share a Join (two Yarns) with this one.
  - flip
```
public java.util.List<Hex> flip()
```
    Flip the Yarns in this Triple. Each Yarn has a list of other Yarns that it meets; this method reverses the positions of any two of the Yarns in this Triple in the list of the third Yarn.
    
    Specified by:
    
    flip in interface Hex
    
    Returns:
    A list of all Triples created or destroyed by this flip.

Class Triple

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

j

Method Detail

createTriple

createTriple

getJoins

getYarns

getHex

valid

contains

contains

contains

doubleOverlap

equals

createSimpleHex

newTriples

flip