diff --git a/common/include/Utilities/HashMap.h b/common/include/Utilities/HashMap.h index afd5e7d622..808138e4c7 100644 --- a/common/include/Utilities/HashMap.h +++ b/common/include/Utilities/HashMap.h @@ -15,157 +15,10 @@ #pragma once -// They move include file in version 2.0.2 of google sparsehash... -#ifdef SPARSEHASH_NEW_INCLUDE_DIR -#include -#include -#include -#include -#else -#include -#include -#include -#include -#endif - #include namespace HashTools { -#define HashFriend(Key,T) friend class HashMap - -/// Defines an equality comparison unary method. -/// Generally intended for internal use only. -#define _EQUALS_UNARY_OP( Type ) bool operator()(const Type s1, const Type s2) const { return s1.Equals( s2 ); } - -/// Defines a hash code unary method -/// Generally intended for internal use only. -#define _HASHCODE_UNARY_OP( Type ) hash_key_t operator()( const Type& val ) const { return val.GetHashCode(); } - -/// -/// Defines an equality comparison method within an encapsulating struct, using the 'unary method' approach. -/// -/// -/// -/// This macro is a shortcut helper to implementing types usable as keys in s. -/// Normally you will want to use instead as it defines both -/// the HashCode predicate and Compare predicate. -/// -/// The code generated by this macro is equivalent to this: -/// -/// // where 'Type' is the parameter used in the macro. -/// struct UnaryEquals -/// { -/// bool operator()(const Type s1, const Type s2) const -/// { -/// return s1.Equals( s2 ); // this operator must be implemented by the user. -/// } -/// }; -/// -/// Note: -/// In C++, the term 'unary method' refers to a method that is implemented as an overload of the -/// operator (), such that the object instance itself acts as a method. -/// Note: -/// This methodology is similar to C# / .NET's object.Equals() method: The class member method -/// implementation of Equals should *not* throw exceptions -- it should instead return false -/// if either side of the comparison is not a matching type. See for details. -/// Note: -/// The reason for this (perhaps seemingly) hogwash red tape is because you can define custom -/// equality behavior for individual hashmaps, which are independent of the type used. The only -/// obvious scenario where such a feature is useful is in -/// -/// -/// -/// -/// -#define DEFINE_EQUALS_UNARY( Type ) struct UnaryEquals{ _EQUALS_UNARY_OP( Type ) } - -/// -/// Defines a hash code predicate within an encapsulating struct; for use in hashable user datatypes -/// -/// -/// -/// This macro is a shortcut helper to implementing types usable as keys in s. -/// Normally you will want to use instead as it defines both -/// the HashCode predicate and Compare predicate. -/// -/// The code generated by this macro is equivalent to this: -/// -/// // where 'Type' is the parameter used in the macro. -/// struct UnaryHashCode -/// { -/// hash_key_t operator()( const Type& val ) const -/// { -/// return val.GetHashCode(); // this member function must be implemented by the user. -/// } -/// }; -/// -/// -/// -/// -/// -/// -#define DEFINE_HASHCODE_UNARY( Type ) struct UnaryHashCode{ _HASHCODE_UNARY_OP( Type ) } - -/// -/// Defines the API for hashcode and comparison unary methods; for use in hashable user datatypes -/// -/// -/// This macro creates APIs that allow the class or struct to be used as a key in a . -/// It requires that the data type implement the following items: -/// * An equality test via an operator== overload. -/// * A public instance member method GetHashCode. -/// The code generated by this macro is equivalent to this: -/// -/// // where 'Type' is the parameter used in the macro. -/// struct UnaryHashCode -/// { -/// hash_key_t operator()( const Type& val ) const -/// { -/// return val.GetHashCode(); // this member function must be implemented by the user. -/// } -/// }; -/// -/// struct UnaryEquals -/// { -/// bool operator()(const Type s1, const Type s2) const -/// { -/// return s1.Equals( s2 ); // this operator must be implemented by the user. -/// } -/// }; -/// -/// Note: -/// In C++, the term 'unary method' refers to a method that is implemented as an overload of the -/// operator (), such that the object instance itself acts as a method. -/// Note: -/// For class types you can use the interface, which also allows you to group -/// multiple types of objects into a single complex HashMap. -/// Note: -/// Generally speaking, you do not use the IHashable interface on simple C-style structs, since it -/// would incur the overhead of a vtbl and could potentially break code that assumes the structs to have -/// 1-to-1 data-to-declaration coorlations. -/// Note: -/// Internally, using this macro is functionally equivalent to using both -/// and . -/// -/// -/// -/// -/// -/// -#define DEFINE_HASH_API( Type ) DEFINE_HASHCODE_UNARY( Type ); DEFINE_EQUALS_UNARY( Type ); - -/// -/// A helper macro for creating custom types that can be used as keys. -/// -/// -/// Use of this macro is only needed if the hashable type in question is a struct that is a private -/// local to the namespace of a containing class. -/// -#define PRIVATE_HASHMAP( Key, T ) \ - typedef SpecializedHashMap Key##HashMap; \ - friend Key##HashMap; - /// /// Type that represents a hashcode; returned by all hash functions. /// @@ -177,187 +30,5 @@ typedef u32 hash_key_t; hash_key_t Hash(const char* data, int len); -struct CommonHashClass; -extern const CommonHashClass GetCommonHash; - -/// -/// A unary-style set of methods for getting the hash code of C++ fundamental types. -/// -/// -/// This class is used to pass hash functions into the class and -/// it's siblings. It houses methods for most of the fundamental types of C++ and the STL, -/// such as all int and float types, and also std::string. All functions can be -/// accessed via the () overload on an instance of the class, such as: -/// -/// const CommonHashClass GetHash; -/// int v = 27; -/// std::string s = "Joe's World!"; -/// hash_key_t hashV = GetHash( v ); -/// hash_key_t hashS = GetHash( s ); -/// -/// Note: -/// In C++, the term 'unary method' refers to a method that is implemented as an overload of the -/// operator (), such that the object instance itself acts as a method. -/// -/// -struct CommonHashClass -{ -public: - // GCC needs empty constructors on const instances, because it likes pointlessness. - CommonHashClass() {} - - hash_key_t DoInt( u32 val ) const - { - u32 key = val; - key = ~key + (key << 15); - key = key ^ (key >> 12); - key = key + (key << 2); - key = key ^ (key >> 4); - key = key * 2057; - key = key ^ (key >> 16); - - return val; - } - - hash_key_t operator()(const std::string& src) const - { - return Hash( src.data(), src.length() ); - } - - hash_key_t operator()( const std::wstring& src ) const - { - return Hash( (const char *)src.data(), src.length() * sizeof( wchar_t ) ); - } - - hash_key_t operator()( const wxString& src ) const - { - return Hash( (const char *)src.data(), src.length() * sizeof( wxChar ) ); - } - - // Returns a hashcode for a character. - // This has function has been optimized to return an even distribution - // across the range of an int value. In theory that should be more rewarding - // to hastable performance than a straight up char lookup. - hash_key_t operator()( const char c1 ) const - { - // Most chars contain values between 0 and 128, so let's mix it up a bit: - int cs = (int)( c1 + (char)64 ); - return ( cs + ( cs<<8 ) + ( cs << 16 ) + (cs << 24 ) ); - } - - hash_key_t operator()( const wchar_t wc1 ) const - { - // Most unicode values are between 0 and 128, with 0-1024 - // making up the bulk of the rest. Everything else is spatially used. - /*int wcs = (int) ( wc1 + 0x2000 ); - return wcs ^ ( wcs + 0x19000 );*/ - - // or maybe I'll just feed it into the int hash: - return GetCommonHash( (u32)wc1 ); - } - - /// - /// Gets the hash code for a 32 bit integer. - /// - /// - /// This method performs a very fast algorithm optimized for typical integral - /// dispersion patterns (which tend to favor a bit heavy on the lower-range of values while - /// leaving the extremes un-used). - /// Note: - /// Implementation is based on an article found here: http://www.concentric.net/~Ttwang/tech/inthash.htm - /// - hash_key_t operator()( const u32 val ) const - { - return DoInt(val); - } - - /// - /// Gets the hash code for a 32 bit integer. - /// - /// - /// This method performs a very fast algorithm optimized for typical integral - /// dispersion patterns (which tend to favor a bit heavy on the lower-range of values while - /// leaving the extremes un-used). - /// Note: - /// Implementation is based on an article found here: http://www.concentric.net/~Ttwang/tech/inthash.htm - /// - hash_key_t operator()( const s32 val ) const - { - return DoInt(val); - } - - /// - /// Gets the hash code for a 64 bit integer. - /// - /// - /// This method performs a very fast algorithm optimized for typical integral - /// dispersion patterns (which tend to favor a bit heavy on the lower-range of values while - /// leaving the extremes un-used). - /// Note: - /// Implementation is based on an article found here: http://www.concentric.net/~Ttwang/tech/inthash.htm - /// - hash_key_t operator()( const u64 val ) const - { - u64 key = val; - key = (~key) + (key << 18); - key = key ^ (key >> 31); - key = key * 21; // key = (key + (key << 2)) + (key << 4); - key = key ^ (key >> 11); - key = key + (key << 6); - key = key ^ (key >> 22); - return (u32) key; - } - - /// - /// Gets the hash code for a 64 bit integer. - /// - /// - /// This method performs a very fast algorithm optimized for typical integral - /// dispersion patterns (which tend to favor a bit heavy on the lower-range of values while - /// leaving the extremes un-used). - /// Note: - /// Implementation is based on an article found here: http://www.concentric.net/~Ttwang/tech/inthash.htm - /// - hash_key_t operator()( const s64 val ) const - { - return GetCommonHash((u64)val); - } - - hash_key_t operator()( const float val ) const - { - // floats do a fine enough job of being scattered about - // the universe: - return *((hash_key_t *)&val); - } - - hash_key_t operator()( const double val ) const - { - // doubles have to be compressed into a 32 bit value: - return GetCommonHash( *((u64*)&val) ); - } - - /// - /// Calculates the hash of a pointer. - /// - /// - /// This method has been optimized to give typical 32 bit pointers a reasonably - /// wide spread across the integer spectrum. - /// Note: - /// This method is optimized for 32 bit pointers only. - /// 64 bit pointer support is implemented but not optimized. - /// - hash_key_t operator()( const void* addr ) const - { -#ifdef _ARCH_64 - return GetCommonHash((u64)addr); -#else - hash_key_t key = (hash_key_t) addr; - return (hash_key_t)((key >> 3) * 2654435761ul); -#endif - } - - -}; - } diff --git a/common/src/Utilities/HashTools.cpp b/common/src/Utilities/HashTools.cpp index 8ffdb0255e..9ce5115214 100644 --- a/common/src/Utilities/HashTools.cpp +++ b/common/src/Utilities/HashTools.cpp @@ -18,17 +18,6 @@ namespace HashTools { -/// -/// Provides access to a set of common hash methods for C fundamental types. -/// -/// -/// The CommonHashClass is implemented using the () operator (sometimes referred to -/// as a predicate), which means that an instance of -/// is required to use the methods. This public global variable provides that instance. -/// -/// -const CommonHashClass GetCommonHash; - #define get16bits(d) (*((const u16 *) (d))) /// diff --git a/pcsx2/gui/GlobalCommands.cpp b/pcsx2/gui/GlobalCommands.cpp index aaa5343727..2258d2c0e7 100644 --- a/pcsx2/gui/GlobalCommands.cpp +++ b/pcsx2/gui/GlobalCommands.cpp @@ -30,8 +30,6 @@ #include "DebugTools/Debug.h" #include "R3000A.h" -using namespace HashTools; - // renderswitch - tells GSdx to go into dx9 sw if "renderswitch" is set. bool renderswitch = false;