/*
Copyright (C) 2005,2009-2010 Electronic Arts, Inc.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1.  Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
2.  Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
3.  Neither the name of Electronic Arts, Inc. ("EA") nor the names of
    its contributors may be used to endorse or promote products derived
    from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

///////////////////////////////////////////////////////////////////////////////
// EASTL/functional.h
// Written and maintained by Paul Pedriana - 2005
///////////////////////////////////////////////////////////////////////////////


#ifndef EASTL_FUNCTIONAL_H
#define EASTL_FUNCTIONAL_H


#include <EASTL/internal/config.h>
#include <EASTL/type_traits.h>


namespace eastl
{

    ///////////////////////////////////////////////////////////////////////
    // Primary C++ functions
    ///////////////////////////////////////////////////////////////////////

    template <typename Argument, typename Result>
    struct unary_function
    {
        typedef Argument argument_type;
        typedef Result   result_type;
    };


    template <typename Argument1, typename Argument2, typename Result>
    struct binary_function
    {
        typedef Argument1 first_argument_type;
        typedef Argument2 second_argument_type;
        typedef Result    result_type;
    };


    template <typename T>
    struct plus : public binary_function<T, T, T>
    {
        T operator()(const T& a, const T& b) const
            { return a + b; }
    };

    template <typename T>
    struct minus : public binary_function<T, T, T>
    {
        T operator()(const T& a, const T& b) const
            { return a - b; }
    };

    template <typename T>
    struct multiplies : public binary_function<T, T, T>
    {
        T operator()(const T& a, const T& b) const
            { return a * b; }
    };

    template <typename T>
    struct divides : public binary_function<T, T, T>
    {
        T operator()(const T& a, const T& b) const
            { return a / b; }
    };

    template <typename T>
    struct modulus : public binary_function<T, T, T>
    {
        T operator()(const T& a, const T& b) const
            { return a % b; }
    };

    template <typename T>
    struct negate : public unary_function<T, T>
    {
        T operator()(const T& a) const
            { return -a; }
    };

    template <typename T>
    struct equal_to : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a == b; }
    };

    template <typename T, typename Compare>
    bool validate_equal_to(const T& a, const T& b, Compare compare)
    {
        return compare(a, b) == compare(b, a);
    }

    template <typename T>
    struct not_equal_to : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a != b; }
    };

    template <typename T, typename Compare>
    bool validate_not_equal_to(const T& a, const T& b, Compare compare)
    {
        return compare(a, b) == compare(b, a); // We want the not equal comparison results to be equal.
    }

    /// str_equal_to
    ///
    /// Compares two 0-terminated string types.
    /// The T types are expected to be iterators or act like iterators.
    ///
    /// Example usage:
    ///     hash_set<const char*, hash<const char*>, str_equal_to<const char*> > stringHashSet;
    ///
    /// Note:
    /// You couldn't use str_equal_to like this:
    ///     bool result = equal("hi", "hi" + 2, "ho", str_equal_to<const char*>());
    /// This is because equal tests an array of something, with each element by
    /// the comparison function. But str_equal_to tests an array of something itself.
    ///
    template <typename T>
    struct str_equal_to : public binary_function<T, T, bool>
    {
        bool operator()(T a, T b) const
        {
            while(*a && (*a == *b))
            {
                ++a;
                ++b;
            }
            return (*a == *b);
        }
    };

    template <typename T>
    struct greater : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a > b; }
    };

    template <typename T, typename Compare>
    bool validate_greater(const T& a, const T& b, Compare compare)
    {
        return !compare(a, b) || !compare(b, a); // If (a > b), then !(b > a)
    }

    template <typename T>
    struct less : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a < b; }
    };

    template <typename T, typename Compare>
    bool validate_less(const T& a, const T& b, Compare compare)
    {
        return !compare(a, b) || !compare(b, a); // If (a < b), then !(b < a)
    }

    template <typename T>
    struct greater_equal : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
        { return a >= b; }
    };

    template <typename T, typename Compare>
    bool validate_greater_equal(const T& a, const T& b, Compare compare)
    {
        return !compare(a, b) || !compare(b, a); // If (a >= b), then !(b >= a)
    }

    template <typename T>
    struct less_equal : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a <= b; }
    };

    template <typename T, typename Compare>
    bool validate_less_equal(const T& a, const T& b, Compare compare)
    {
        return !compare(a, b) || !compare(b, a); // If (a <= b), then !(b <= a)
    }

    template <typename T>
    struct logical_and : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a && b; }
    };

    template <typename T>
    struct logical_or : public binary_function<T, T, bool>
    {
        bool operator()(const T& a, const T& b) const
            { return a || b; }
    };

    template <typename T>
    struct logical_not : public unary_function<T, bool>
    {
        bool operator()(const T& a) const
            { return !a; }
    };



    ///////////////////////////////////////////////////////////////////////
    // Dual type functions
    ///////////////////////////////////////////////////////////////////////

    template <typename T, typename U>
    struct equal_to_2 : public binary_function<T, U, bool>
    {
        bool operator()(const T& a, const U& b) const
            { return a == b; }
    };

    template <typename T, typename U>
    struct not_equal_to_2 : public binary_function<T, U, bool>
    {
        bool operator()(const T& a, const U& b) const
            { return a != b; }
    };

    template <typename T, typename U>
    struct less_2 : public binary_function<T, U, bool>
    {
        bool operator()(const T& a, const U& b) const
            { return a < b; }
    };




    /// unary_negate
    ///
    template <typename Predicate>
    class unary_negate : public unary_function<typename Predicate::argument_type, bool>
    {
        protected:
            Predicate mPredicate;
        public:
            explicit unary_negate(const Predicate& a)
                : mPredicate(a) {}
            bool operator()(const typename Predicate::argument_type& a) const
                { return !mPredicate(a); }
    };

    template <typename Predicate>
    inline unary_negate<Predicate> not1(const Predicate& predicate)
        { return unary_negate<Predicate>(predicate); }



    /// binary_negate
    ///
    template <typename Predicate>
    class binary_negate : public binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>
    {
        protected:
            Predicate mPredicate;
        public:
            explicit binary_negate(const Predicate& a)
                : mPredicate(a) { }
            bool operator()(const typename Predicate::first_argument_type& a, const typename Predicate::second_argument_type& b) const
                { return !mPredicate(a, b); }
    };

    template <typename Predicate>
    inline binary_negate<Predicate> not2(const Predicate& predicate)
        { return binary_negate<Predicate>(predicate); }




    ///////////////////////////////////////////////////////////////////////
    // bind
    ///////////////////////////////////////////////////////////////////////

    /// bind1st
    ///
    template <typename Operation>
    class binder1st : public unary_function<typename Operation::second_argument_type, typename Operation::result_type>
    {
        protected:
            typename Operation::first_argument_type value;
            Operation op;

        public:
            binder1st(const Operation& x, const typename Operation::first_argument_type& y)
                : value(y), op(x) { }

            typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const
                { return op(value, x); }

            typename Operation::result_type operator()(typename Operation::second_argument_type& x) const
                { return op(value, x); }
    };


    template <typename Operation, typename T>
    inline binder1st<Operation> bind1st(const Operation& op, const T& x)
    {
        typedef typename Operation::first_argument_type value;
        return binder1st<Operation>(op, value(x));
    }


    /// bind2nd
    ///
    template <typename Operation>
    class binder2nd : public unary_function<typename Operation::first_argument_type, typename Operation::result_type>
    {
        protected:
            Operation op;
            typename Operation::second_argument_type value;

        public:
            binder2nd(const Operation& x, const typename Operation::second_argument_type& y)
                : op(x), value(y) { }

            typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const
                { return op(x, value); }

            typename Operation::result_type operator()(typename Operation::first_argument_type& x) const
                { return op(x, value); }
    };


    template <typename Operation, typename T>
    inline binder2nd<Operation> bind2nd(const Operation& op, const T& x)
    {
        typedef typename Operation::second_argument_type value;
        return binder2nd<Operation>(op, value(x));
    }




    ///////////////////////////////////////////////////////////////////////
    // pointer_to_unary_function
    ///////////////////////////////////////////////////////////////////////

    /// pointer_to_unary_function
    ///
    /// This is an adapter template which converts a pointer to a standalone
    /// function to a function object. This allows standalone functions to 
    /// work in many cases where the system requires a function object.
    ///
    /// Example usage:
    ///     ptrdiff_t Rand(ptrdiff_t n) { return rand() % n; } // Note: The C rand function is poor and slow.
    ///     pointer_to_unary_function<ptrdiff_t, ptrdiff_t> randInstance(Rand);
    ///     random_shuffle(pArrayBegin, pArrayEnd, randInstance);
    ///
    template <typename Arg, typename Result>
    class pointer_to_unary_function : public unary_function<Arg, Result>
    {
    protected:
        Result (*mpFunction)(Arg);

    public:
        pointer_to_unary_function()
            { }

        explicit pointer_to_unary_function(Result (*pFunction)(Arg))
            : mpFunction(pFunction) { }

        Result operator()(Arg x) const
            { return mpFunction(x); } 
    };


    /// ptr_fun
    ///
    /// This ptr_fun is simply shorthand for usage of pointer_to_unary_function.
    ///
    /// Example usage (actually, you don't need to use ptr_fun here, but it works anyway):
    ///    int factorial(int x) { return (x > 1) ? (x * factorial(x - 1)) : x; }
    ///    transform(pIntArrayBegin, pIntArrayEnd, pIntArrayBegin, ptr_fun(factorial));
    ///
    template <typename Arg, typename Result>
    inline pointer_to_unary_function<Arg, Result> ptr_fun(Result (*pFunction)(Arg))
        { return pointer_to_unary_function<Arg, Result>(pFunction); }





    ///////////////////////////////////////////////////////////////////////
    // pointer_to_binary_function
    ///////////////////////////////////////////////////////////////////////

    /// pointer_to_binary_function
    ///
    /// This is an adapter template which converts a pointer to a standalone
    /// function to a function object. This allows standalone functions to 
    /// work in many cases where the system requires a function object.
    ///
    template <typename Arg1, typename Arg2, typename Result>
    class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
    {
    protected:
        Result (*mpFunction)(Arg1, Arg2);

    public:
        pointer_to_binary_function()
            { }

        explicit pointer_to_binary_function(Result (*pFunction)(Arg1, Arg2))
            : mpFunction(pFunction) {}

        Result operator()(Arg1 x, Arg2 y) const
            { return mpFunction(x, y); }
    };


    /// This ptr_fun is simply shorthand for usage of pointer_to_binary_function.
    ///
    /// Example usage (actually, you don't need to use ptr_fun here, but it works anyway):
    ///    int multiply(int x, int y) { return x * y; }
    ///    transform(pIntArray1Begin, pIntArray1End, pIntArray2Begin, pIntArray1Begin, ptr_fun(multiply));
    ///
    template <typename Arg1, typename Arg2, typename Result>
    inline pointer_to_binary_function<Arg1, Arg2, Result> ptr_fun(Result (*pFunction)(Arg1, Arg2))
        { return pointer_to_binary_function<Arg1, Arg2, Result>(pFunction); }






    ///////////////////////////////////////////////////////////////////////
    // mem_fun
    // mem_fun1
    //
    // Note that mem_fun calls member functions via *pointers* to classes 
    // and not instances of classes. mem_fun_ref is for calling functions
    // via instances of classes or references to classes.
    //
    ///////////////////////////////////////////////////////////////////////

    /// mem_fun_t
    ///
    /// Member function with no arguments.
    ///
    template <typename Result, typename T> 
    class mem_fun_t : public unary_function<T*, Result>
    {
    public:
        typedef Result (T::*MemberFunction)();

        EA_FORCE_INLINE explicit mem_fun_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(T* pT) const
        {
            return (pT->*mpMemberFunction)();
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// mem_fun1_t
    ///
    /// Member function with one argument.
    ///
    template <typename Result, typename T, typename Argument>
    class mem_fun1_t : public binary_function<T*, Argument, Result>
    {
    public:
        typedef Result (T::*MemberFunction)(Argument);

        EA_FORCE_INLINE explicit mem_fun1_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(T* pT, Argument arg) const
        {
            return (pT->*mpMemberFunction)(arg);
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// const_mem_fun_t
    ///
    /// Const member function with no arguments.
    /// Note that we inherit from unary_function<const T*, Result>
    /// instead of what the C++ standard specifies: unary_function<T*, Result>.
    /// The C++ standard is in error and this has been recognized by the defect group.
    ///
    template <typename Result, typename T>
    class const_mem_fun_t : public unary_function<const T*, Result>
    {
    public:
        typedef Result (T::*MemberFunction)() const;

        EA_FORCE_INLINE explicit const_mem_fun_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(const T* pT) const
        {
            return (pT->*mpMemberFunction)();
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// const_mem_fun1_t
    ///
    /// Const member function with one argument.
    /// Note that we inherit from unary_function<const T*, Result>
    /// instead of what the C++ standard specifies: unary_function<T*, Result>.
    /// The C++ standard is in error and this has been recognized by the defect group.
    ///
    template <typename Result, typename T, typename Argument>
    class const_mem_fun1_t : public binary_function<const T*, Argument, Result>
    {
    public:
        typedef Result (T::*MemberFunction)(Argument) const;

        EA_FORCE_INLINE explicit const_mem_fun1_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(const T* pT, Argument arg) const
        {
            return (pT->*mpMemberFunction)(arg);
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// mem_fun
    ///
    /// This is the high level interface to the mem_fun_t family.
    ///
    /// Example usage:
    ///    struct TestClass { void print() { puts("hello"); } }
    ///    TestClass* pTestClassArray[3] = { ... };
    ///    for_each(pTestClassArray, pTestClassArray + 3, &TestClass::print);
    ///
    template <typename Result, typename T>
    EA_FORCE_INLINE mem_fun_t<Result, T>
    mem_fun(Result (T::*MemberFunction)())
    {
        return eastl::mem_fun_t<Result, T>(MemberFunction);
    }

    template <typename Result, typename T, typename Argument>
    EA_FORCE_INLINE mem_fun1_t<Result, T, Argument>
    mem_fun(Result (T::*MemberFunction)(Argument))
    {
        return eastl::mem_fun1_t<Result, T, Argument>(MemberFunction);
    }

    template <typename Result, typename T>
    EA_FORCE_INLINE const_mem_fun_t<Result, T>
    mem_fun(Result (T::*MemberFunction)() const)
    {
        return eastl::const_mem_fun_t<Result, T>(MemberFunction);
    }

    template <typename Result, typename T, typename Argument>
    EA_FORCE_INLINE const_mem_fun1_t<Result, T, Argument>
    mem_fun(Result (T::*MemberFunction)(Argument) const)
    {
        return eastl::const_mem_fun1_t<Result, T, Argument>(MemberFunction);
    }





    ///////////////////////////////////////////////////////////////////////
    // mem_fun_ref
    // mem_fun1_ref
    //
    ///////////////////////////////////////////////////////////////////////

    /// mem_fun_ref_t
    ///
    template <typename Result, typename T>
    class mem_fun_ref_t : public unary_function<T, Result>
    {
    public:
        typedef Result (T::*MemberFunction)();

        EA_FORCE_INLINE explicit mem_fun_ref_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(T& t) const
        {
            return (t.*mpMemberFunction)();
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// mem_fun1_ref_t
    ///
    template <typename Result, typename T, typename Argument>
    class mem_fun1_ref_t : public binary_function<T, Argument, Result>
    {
    public:
        typedef Result (T::*MemberFunction)(Argument);

        EA_FORCE_INLINE explicit mem_fun1_ref_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(T& t, Argument arg) const
        {
            return (t.*mpMemberFunction)(arg);
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// const_mem_fun_ref_t
    ///
    template <typename Result, typename T>
    class const_mem_fun_ref_t : public unary_function<T, Result>
    {
    public:
        typedef Result (T::*MemberFunction)() const;

        EA_FORCE_INLINE explicit const_mem_fun_ref_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(const T& t) const
        {
            return (t.*mpMemberFunction)();
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// const_mem_fun1_ref_t
    ///
    template <typename Result, typename T, typename Argument>
    class const_mem_fun1_ref_t : public binary_function<T, Argument, Result>
    {
    public:
        typedef Result (T::*MemberFunction)(Argument) const;

        EA_FORCE_INLINE explicit const_mem_fun1_ref_t(MemberFunction pMemberFunction)
            : mpMemberFunction(pMemberFunction)
        {
            // Empty
        }

        EA_FORCE_INLINE Result operator()(const T& t, Argument arg) const
        {
            return (t.*mpMemberFunction)(arg);
        }

    protected:
        MemberFunction mpMemberFunction;
    };


    /// mem_fun_ref
    /// Example usage:
    ///    struct TestClass { void print() { puts("hello"); } }
    ///    TestClass testClassArray[3];
    ///    for_each(testClassArray, testClassArray + 3, &TestClass::print);
    ///
    template <typename Result, typename T>
    EA_FORCE_INLINE mem_fun_ref_t<Result, T>
    mem_fun_ref(Result (T::*MemberFunction)())
    {
        return eastl::mem_fun_ref_t<Result, T>(MemberFunction);
    }

    template <typename Result, typename T, typename Argument>
    EA_FORCE_INLINE mem_fun1_ref_t<Result, T, Argument>
    mem_fun_ref(Result (T::*MemberFunction)(Argument))
    {
        return eastl::mem_fun1_ref_t<Result, T, Argument>(MemberFunction);
    }

    template <typename Result, typename T>
    EA_FORCE_INLINE const_mem_fun_ref_t<Result, T>
    mem_fun_ref(Result (T::*MemberFunction)() const)
    {
        return eastl::const_mem_fun_ref_t<Result, T>(MemberFunction);
    }

    template <typename Result, typename T, typename Argument>
    EA_FORCE_INLINE const_mem_fun1_ref_t<Result, T, Argument>
    mem_fun_ref(Result (T::*MemberFunction)(Argument) const)
    {
        return eastl::const_mem_fun1_ref_t<Result, T, Argument>(MemberFunction);
    }




    ///////////////////////////////////////////////////////////////////////
    // hash
    ///////////////////////////////////////////////////////////////////////

    template <typename T> struct hash;

    template <typename T> struct hash<T*> // Note that we use the pointer as-is and don't divide by sizeof(T*). This is because the table is of a prime size and this division doesn't benefit distribution.
        { size_t operator()(T* p) const { return size_t(uintptr_t(p)); } };

    template <> struct hash<bool>
        { size_t operator()(bool val) const { return static_cast<size_t>(val); } };

    template <> struct hash<char>
        { size_t operator()(char val) const { return static_cast<size_t>(val); } };

    template <> struct hash<signed char>
        { size_t operator()(signed char val) const { return static_cast<size_t>(val); } };

    template <> struct hash<unsigned char>
        { size_t operator()(unsigned char val) const { return static_cast<size_t>(val); } };

    #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type...
        template <> struct hash<wchar_t>
            { size_t operator()(wchar_t val) const { return static_cast<size_t>(val); } };
    #endif

    template <> struct hash<signed short>
        { size_t operator()(short val) const { return static_cast<size_t>(val); } };

    template <> struct hash<unsigned short>
        { size_t operator()(unsigned short val) const { return static_cast<size_t>(val); } };

    template <> struct hash<signed int>
        { size_t operator()(signed int val) const { return static_cast<size_t>(val); } };

    template <> struct hash<unsigned int>
        { size_t operator()(unsigned int val) const { return static_cast<size_t>(val); } };

    template <> struct hash<signed long>
        { size_t operator()(signed long val) const { return static_cast<size_t>(val); } };

    template <> struct hash<unsigned long>
        { size_t operator()(unsigned long val) const { return static_cast<size_t>(val); } };

    template <> struct hash<signed long long>
        { size_t operator()(signed long long val) const { return static_cast<size_t>(val); } };

    template <> struct hash<unsigned long long>
        { size_t operator()(unsigned long long val) const { return static_cast<size_t>(val); } };

    template <> struct hash<float>
        { size_t operator()(float val) const { return static_cast<size_t>(val); } };

    template <> struct hash<double>
        { size_t operator()(double val) const { return static_cast<size_t>(val); } };

    template <> struct hash<long double>
        { size_t operator()(long double val) const { return static_cast<size_t>(val); } };


    ///////////////////////////////////////////////////////////////////////////
    // string hashes
    //
    // Note that our string hashes here intentionally are slow for long strings.
    // The reasoning for this is so:
    //    - The large majority of hashed strings are only a few bytes long.
    //    - The hash function is significantly more efficient if it can make this assumption.
    //    - The user is welcome to make a custom hash for those uncommon cases where
    //      long strings need to be hashed. Indeed, the user can probably make a 
    //      special hash customized for such strings that's better than what we provide.
    ///////////////////////////////////////////////////////////////////////////

    template <> struct hash<char8_t*>
    {
        size_t operator()(const char8_t* p) const
        {
            size_t c, result = 2166136261U;  // FNV1 hash. Perhaps the best string hash.
            while((c = (uint8_t)*p++) != 0)  // Using '!=' disables compiler warnings.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    template <> struct hash<const char8_t*>
    {
        size_t operator()(const char8_t* p) const
        {
            size_t c, result = 2166136261U;
            while((c = (uint8_t)*p++) != 0) // cast to unsigned 8 bit.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    template <> struct hash<char16_t*>
    {
        size_t operator()(const char16_t* p) const
        {
            size_t c, result = 2166136261U;
            while((c = (uint16_t)*p++) != 0) // cast to unsigned 16 bit.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    template <> struct hash<const char16_t*>
    {
        size_t operator()(const char16_t* p) const
        {
            size_t c, result = 2166136261U;
            while((c = (uint16_t)*p++) != 0) // cast to unsigned 16 bit.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    template <> struct hash<char32_t*>
    {
        size_t operator()(const char32_t* p) const
        {
            size_t c, result = 2166136261U;
            while((c = (uint32_t)*p++) != 0) // cast to unsigned 32 bit.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    template <> struct hash<const char32_t*>
    {
        size_t operator()(const char32_t* p) const
        {
            size_t c, result = 2166136261U;
            while((c = (uint32_t)*p++) != 0) // cast to unsigned 32 bit.
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };

    /// string_hash
    ///
    /// Defines a generic string hash for an arbitrary EASTL basic_string container.
    ///
    /// Example usage:
    ///    eastl::hash_set<MyString, eastl::string_hash<MyString> > hashSet;
    ///
    template <typename String>
    struct string_hash
    {
        typedef String                                         string_type;
        typedef typename String::value_type                    value_type;
        typedef typename eastl::add_unsigned<value_type>::type unsigned_value_type;

        size_t operator()(const string_type& s) const
        {
            const unsigned_value_type* p = (const unsigned_value_type*)s.c_str();
            size_t c, result = 2166136261U;
            while((c = *p++) != 0)
                result = (result * 16777619) ^ c;
            return (size_t)result;
        }
    };


} // namespace eastl


#endif // Header include guard