ehash.h

Go to the documentation of this file.

/*
* Copyright (c) 2009-2019 Brian Waters
* Copyright (c) 2019 Sprint
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
 
#ifndef __ehash_h_included
#define __ehash_h_included
 
#include "ebase.h"
#include "estring.h"
#include "eerror.h"
 
 
class EHash
{
public:
   static ULong getHash(EString &str);
   static ULong getHash(cpChar val, ULong len);
   static ULong getHash(cpUChar val, ULong len);
 
private:
   static ULong m_crcTable[256];
};
 
 
//
// ESipHash24 is adapted from the C reference implementation located at
//    https://github.com/veorq/SipHash which is licensed to public domain by
//    the [CC0 1.0 Universal] license.
//
 
DECLARE_ERROR(ESipHash24Error_InvalidKeyLength);
 
class ESipHash24
{
public:
   class Key
   {
   public:
      Key() : data_{0} {}
      Key(const Key &k) { assign(k.data_,sizeof(k.data_)); }
      Key(cpUChar k, const size_t len) { assign(k,len); }
 
      operator cpUChar() const { return data_; }
      cpUChar data() const { return data_; }
 
      Key& assign(cpUChar k, const size_t len)
      {
         size_t i = 0;
         for (; i<min(len,sizeof(data_)); i++)
            data_[i] = k[i];
         for( ; i < sizeof(data_); i++)
            data_[i] = 0;
         return *this;
      }
   private:
      UChar data_[16];
   };
 
   static Key& setKey(const Key& k) { return key_ = k; }
   static Key& setKey(cpUChar val, const size_t len) { return key_.assign(val, len); }
   static const Key& key() { return key_; }
 
   static ULong getHash32(EString &str, const Key &key=key_)
   {
      return getHash32(reinterpret_cast<cpUChar>(str.c_str()), str.length(), key);
   }
   static ULong getHash32(cpChar val, const size_t len, const Key &key=key_)
   {
      return getHash32(reinterpret_cast<cpUChar>(val), len, key);
   }
   static ULong getHash32(cpUChar in, const size_t inlen, const Key &key=key_);
   static Bool getHash32(cpUChar in, const size_t inlen, pUChar out, const size_t outlen, const Key &key=key_);
 
   static ULongLong getHash64(EString &str, const Key &key=key_)
   {
      return getHash64(reinterpret_cast<cpUChar>(str.c_str()), str.length(), key);
   }
   static ULongLong getHash64(cpChar val, const size_t len, const Key &key=key_)
   {
      return getHash64(reinterpret_cast<cpUChar>(val), len, key);
   }
   static ULongLong getHash64(cpUChar in, const size_t inlen, const Key &key=key_);
   static Bool getHash64(cpUChar in, size_t inlen, pUChar out, const size_t outlen, const Key &key=key_);
 
   static Bool getHash128(EString &str, pUChar out, const size_t outlen, const Key &key=key_)
   {
      return getHash128(reinterpret_cast<cpUChar>(str.c_str()), str.length(), out, outlen, key);
   }
   static Bool getHash128(cpChar val, size_t len, pUChar out, const size_t outlen, const Key &key=key_)
   {
      return getHash128(reinterpret_cast<cpUChar>(val), len, out, outlen, key);
   }
   static Bool getHash128(cpUChar in, size_t inlen, pUChar out, const size_t outlen, const Key &key=key_);
 
private:
   static Bool getFullHash(cpUChar in, size_t inlen, cpUChar k, pUChar out, const size_t outlen);
   static Bool getHalfHash(cpUChar in, size_t inlen, cpUChar k, pUChar out, const size_t outlen);
 
   static Key key_;
};
 
#endif // #define __ehash_h_included