// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.simpletypes;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.typeutils.*;

public abstract class SimpleKeyValuePair<T extends SimpleKeyValuePair> extends CompareSupport<T> implements SimpleType
{
    public static final SimpleKeyValuePair[] EMPTY_ARRAY = new SimpleKeyValuePair[0];

    abstract public Object getKey();

    abstract public Object getValue();

    public String toStringValue()
    {
        return Objects.toStringNullToEmpty( getValue() );
    }

    @Override
    public String toString()
    {
        return getWhatWeAre() + "( " + getKey() + ", " + getValue() + LLtoStringSuffix();
    }

    protected String LLtoStringSuffix()
    {
        return " )";
    }

    protected String getWhatWeAre()
    {
        return "SimpleKeyValuePair";
    }

    @Override
    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof SimpleKeyValuePair) && equals( (SimpleKeyValuePair) o ));
    }

    public boolean equals( SimpleKeyValuePair them )
    {
        return (this == them) || //
               ((them != null) && //
                equal( this.getKey(), them.getKey() ) && //
                equal( this.getValue(), them.getValue() ) && //
                LLequalsSuffix( them ));
    }

    // Subclass cross over pattern
    protected boolean LLequalsSuffix( SimpleKeyValuePair them )
    {
        return them.LLLequalsSuffix( this );
    }

    // Subclass cross over pattern
    protected boolean LLLequalsSuffix( SimpleKeyValuePair them )
    {
        return true;
    }

    @Override
    public int hashCode()
    {
        return hashCodeEm( calcHashCode( getKey() ), //
                           calcHashCode( getValue() ), //
                           LLhashCodeSuffix() );
    }

    protected int LLhashCodeSuffix()
    {
        return 0;
    }

    @Override
    public int compareTo( T them )
    {
        return compareEm( compareObjects( this.getValue(), them.getValue() ), //
                          compareObjects( this.getKey(), them.getKey() ), //
                          LLcompareToSuffix( them ) );
    }

    // Subclass cross over pattern
    protected int LLcompareToSuffix( SimpleKeyValuePair them )
    {
        return them.LLLcompareToSuffix( this );
    }

    // Subclass cross over pattern
    protected int LLLcompareToSuffix( SimpleKeyValuePair them )
    {
        return 0;
    }
}