// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

* Copyright (C) 1996-2012, International Business Machines Corporation and

* others. All Rights Reserved.

*******************************************************************************

*/

//===============================================================================

//

// File sortkey.cpp

//

//

//

// Created by: Helena Shih

//

// Modification History:

//

//  Date         Name          Description

//

//  6/20/97      helena        Java class name change.

//  6/23/97      helena        Added comments to make code more readable.

//  6/26/98      erm           Changed to use byte arrays instead of UnicodeString

//  7/31/98      erm           hashCode: minimum inc should be 2 not 1,

//                             Cleaned up operator=

// 07/12/99      helena        HPUX 11 CC port.

// 03/06/01      synwee        Modified compareTo, to handle the result of

//                             2 string similar in contents, but one is longer

//                             than the other

//===============================================================================

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION

#include "unicode/sortkey.h"

#include "cmemory.h"

#include "uelement.h"

#include "ustr_imp.h"

U_NAMESPACE_BEGIN

// A hash code of kInvalidHashCode indicates that the hash code needs

// to be computed. A hash code of kEmptyHashCode is used for empty keys

// and for any key whose computed hash code is kInvalidHashCode.

static const int32_t kInvalidHashCode = 0;

static const int32_t kEmptyHashCode = 1;

// The "bogus hash code" replaces a separate fBogus flag.

static const int32_t kBogusHashCode = 2;

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationKey)

CollationKey::CollationKey()

    : UObject(), fFlagAndLength(0),

      fHashCode(kEmptyHashCode)

{

}

// Create a collation key from a bit array.

CollationKey::CollationKey(const uint8_t* newValues, int32_t count)

    : UObject(), fFlagAndLength(count),

      fHashCode(kInvalidHashCode)

{

    if (count < 0 || (newValues == NULL && count != 0) ||

            (count > getCapacity() && reallocate(count, 0) == NULL)) {

        setToBogus();

        return;

    }

    if (count > 0) {

        uprv_memcpy(getBytes(), newValues, count);

    }

}

CollationKey::CollationKey(const CollationKey& other)

    : UObject(other), fFlagAndLength(other.getLength()),

      fHashCode(other.fHashCode)

{

    if (other.isBogus())

    {

        setToBogus();

        return;

    }

    int32_t length = fFlagAndLength;

    if (length > getCapacity() && reallocate(length, 0) == NULL) {

        setToBogus();

        return;

    }

    if (length > 0) {

        uprv_memcpy(getBytes(), other.getBytes(), length);

    }

}

CollationKey::~CollationKey()

{

    if(fFlagAndLength < 0) { uprv_free(fUnion.fFields.fBytes); }

}

uint8_t *CollationKey::reallocate(int32_t newCapacity, int32_t length) {

    uint8_t *newBytes = static_cast<uint8_t *>(uprv_malloc(newCapacity));

    if(newBytes == NULL) { return NULL; }

    if(length > 0) {

        uprv_memcpy(newBytes, getBytes(), length);

    }

    if(fFlagAndLength < 0) { uprv_free(fUnion.fFields.fBytes); }

    fUnion.fFields.fBytes = newBytes;

    fUnion.fFields.fCapacity = newCapacity;

    fFlagAndLength |= 0x80000000;

    return newBytes;

}

void CollationKey::setLength(int32_t newLength) {

    // U_ASSERT(newLength >= 0 && newLength <= getCapacity());

    fFlagAndLength = (fFlagAndLength & 0x80000000) | newLength;

    fHashCode = kInvalidHashCode;

}

// set the key to an empty state

CollationKey&

CollationKey::reset()

{

    fFlagAndLength &= 0x80000000;

    fHashCode = kEmptyHashCode;

    return *this;

}

// set the key to a "bogus" or invalid state

CollationKey&

CollationKey::setToBogus()

{

    fFlagAndLength &= 0x80000000;

    fHashCode = kBogusHashCode;

    return *this;

}

bool

CollationKey::operator==(const CollationKey& source) const

{

    return getLength() == source.getLength() &&

            (this == &source ||

             uprv_memcmp(getBytes(), source.getBytes(), getLength()) == 0);

}

const CollationKey&

CollationKey::operator=(const CollationKey& other)

{

    if (this != &other)

    {

        if (other.isBogus())

        {

            return setToBogus();

        }

        int32_t length = other.getLength();

        if (length > getCapacity() && reallocate(length, 0) == NULL) {

            return setToBogus();

        }

        if (length > 0) {

            uprv_memcpy(getBytes(), other.getBytes(), length);

        }

        fFlagAndLength = (fFlagAndLength & 0x80000000) | length;

        fHashCode = other.fHashCode;

    }

    return *this;

}

// Bitwise comparison for the collation keys.

Collator::EComparisonResult

CollationKey::compareTo(const CollationKey& target) const

{

    UErrorCode errorCode = U_ZERO_ERROR;

    return static_cast<Collator::EComparisonResult>(compareTo(target, errorCode));

}

// Bitwise comparison for the collation keys.

UCollationResult

CollationKey::compareTo(const CollationKey& target, UErrorCode &status) const

{

  if(U_SUCCESS(status)) {

    const uint8_t *src = getBytes();

    const uint8_t *tgt = target.getBytes();

    // are we comparing the same string

    if (src == tgt)

        return  UCOL_EQUAL;

    UCollationResult result;

    // are we comparing different lengths?

    int32_t minLength = getLength();

    int32_t targetLength = target.getLength();

    if (minLength < targetLength) {

        result = UCOL_LESS;

    } else if (minLength == targetLength) {

        result = UCOL_EQUAL;

    } else {

        minLength = targetLength;

        result = UCOL_GREATER;

    }

    if (minLength > 0) {

        int diff = uprv_memcmp(src, tgt, minLength);

        if (diff > 0) {

            return UCOL_GREATER;

        }

        else

            if (diff < 0) {

                return UCOL_LESS;

            }

    }

    return result;

  } else {

    return UCOL_EQUAL;

  }

}

#ifdef U_USE_COLLATION_KEY_DEPRECATES

// Create a copy of the byte array.

uint8_t*

CollationKey::toByteArray(int32_t& count) const

{

    uint8_t *result = (uint8_t*) uprv_malloc( sizeof(uint8_t) * fCount );

    if (result == NULL)

    {

        count = 0;

    }

    else

    {

        count = fCount;

        if (count > 0) {

            uprv_memcpy(result, fBytes, fCount);

        }

    }

    return result;

}

#endif

static int32_t

computeHashCode(const uint8_t *key, int32_t  length) {

    const char *s = reinterpret_cast<const char *>(key);

    int32_t hash;

    if (s == NULL || length == 0) {

        hash = kEmptyHashCode;

    } else {

        hash = ustr_hashCharsN(s, length);

        if (hash == kInvalidHashCode || hash == kBogusHashCode) {

            hash = kEmptyHashCode;

        }

    }

    return hash;

}

int32_t

CollationKey::hashCode() const

{

    // (Cribbed from UnicodeString)

    // We cache the hashCode; when it becomes invalid, due to any change to the

    // string, we note this by setting it to kInvalidHashCode. [LIU]

    // Note: This method is semantically const, but physically non-const.

    if (fHashCode == kInvalidHashCode)

    {

        fHashCode = computeHashCode(getBytes(), getLength());

    }

    return fHashCode;

}

U_NAMESPACE_END

U_CAPI int32_t U_EXPORT2

ucol_keyHashCode(const uint8_t *key, 

                       int32_t  length)

{

    return icu::computeHashCode(key, length);

}

#endif /* #if !UCONFIG_NO_COLLATION */