Determining winning hand in poker

// These are masks of 13 cards each.
    public  static final long SINGLE_MASK  = (1L<<13) - (1L<<0);
    public  static final long PAIR_MASK    = (1L<<26) - (1L<<13);
    public  static final long TRIO_MASK    = (1L<<39) - (1L<<26);
    public  static final long QUAD_MASK    = (1L<<52) - (1L<<39);

    // This is a mask for one particular rank (4 bits).
    public  static final long RANK_MASK    = (1L<<0)  | (1L<<13) |
                                             (1L<<26) | (1L<<39);

    // This is used to detect a straight.
    private static final long STRAIGHT_VAL = (1L<<5) - (1L<<0);

    // The descriptor of the hand which can be used for comparisons.
    private final long handInfo;

@Getter @EqualsAndHashCode(of="cards") class Hand implements Comparable<Hand> {
        Hand(Iterable<Card> cards) {
                assert Iterables.size(cards) == CARDS_IN_HAND;
                this.cards = ImmutableSortedSet.copyOf(cards);
                checkArgument(this.cards.size() == 5, cards);
                int  suitBits = 0;
                long info     = 0;

                for (final Card c : this.cards) {
                        final int rank = c.rank().value() - 2;
                        long rankBits  = info & (RANK_MASK << rank);

                        if (rankBits == 0) {
                            // First card of this rank, add it to singles.
                            rankBits = 1L << rank;
                        } else {
                            // Already have card of this rank, shift it to
                            // next count.
                            rankBits |= (rankBits << 13);
                        }
                        info ^= rankBits;
                        suitBits |= (1 << (c.suit().symbol() - 'A'));
                }

                // Determine straight and flush.
                long singleCards = info & SINGLE_MASK;
                singleCards >>>= Long.numberOfTrailingZeros(singleCards);
                isStraight = (singleCards == STRAIGHT_VAL);
                isFlush    = (Integer.bitCount(suitBits) == 1);
                handInfo   = info;
        }

/**
     * Returns a positive number if {@code this} is stronger than {@code other},
     * a negative number if it's weaker,
     * and 0 if they're equally strong.
     */
    @Override public int compareTo(Hand other) {
            final HandValue myHandValue = toHandValue();
            final HandValue otherHandValue = other.toHandValue();
            int result = myHandValue.compareTo(otherHandValue);
            if (result!=0) return result;

            assert myHandValue == otherHandValue;

            return Long.compare(handInfo, other.handInfo());
    }

@RequiredArgsConstructor enum HandValue implements Predicate<Hand> {
        HIGH_CARD {
                @Override public boolean apply(Hand input) {
                        long handInfo = input.handInfo();
                        return Long.bitCount(handInfo & Hand.SINGLE_MASK) == 5;
                }
        },
        PAIR {
                @Override public boolean apply(Hand input) {
                    long handInfo = input.handInfo();
                    return (Long.bitCount(handInfo & Hand.PAIR_MASK) == 1) &&
                           (Long.bitCount(handInfo & Hand.SINGLE_MASK) == 3);
                }
        },
        TWO_PAIRS {
                @Override public boolean apply(Hand input) {
                    long handInfo = input.handInfo();
                    return (Long.bitCount(handInfo & Hand.PAIR_MASK) == 2);
                }
        },
        THREE_OF_A_KIND {
                @Override public boolean apply(Hand input) {
                    long handInfo = input.handInfo();
                    return (Long.bitCount(handInfo & Hand.TRIO_MASK) == 1) &&
                           (Long.bitCount(handInfo & Hand.SINGLE_MASK) == 2);
                }
        },
        STRAIGHT {
                @Override public boolean apply(Hand input) {
                    return input.isStraight();
                }
        },
        FLUSH {
                @Override public boolean apply(Hand input) {
                    return input.isFlush();
                }
        },
        FULL_HOUSE {
                @Override public boolean apply(Hand input) {
                    long handInfo = input.handInfo();
                    return (Long.bitCount(handInfo & Hand.TRIO_MASK) == 1) &&
                           (Long.bitCount(handInfo & Hand.PAIR_MASK) == 1);
                }
        },
        FOUR_OF_A_KIND {
                @Override public boolean apply(Hand input) {
                    long handInfo = input.handInfo();
                    return Long.bitCount(handInfo & Hand.QUAD_MASK) == 1;
                }
        },
        STRAIGHT_FLUSH {
                @Override public boolean apply(Hand input) {
                    return input.isStraight() && input.isFlush();
                }
        },
        ;
    }

// Ace-2-3-4-5
private static final long WHEEL = 0x100fL;

if ((handInfo & SINGLE_MASK) == WHEEL) {
    isStraight = true;
    // Clear out all cards, or do handInfo ^= 0x1000 to clear just the ace.
    // This keeps the comparison correct with other straights.
    handInfo ^= WHEEL;
}