DtIntersectorCacheKey.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtCachedIntersectorKey.h,v $ $Revision: 1.9 $ $State: Exp $
******************************************************************************/


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtIntersector.h>

#include <string.h>

namespace makVrv
{
   class DtIntersectorCacheKey
   {
   public:
      DtIntersectorCacheKey(DtIntersector::IntersectProperties p, 
         DtIntersector::DynamicOceanProperties op, double x, double y, double z)
      {
         myVals[0] = x; myVals[1] = y; myVals[2] = z;
         myVals[3] = 99999999.99999999; myVals[4] = 99999999.99999999; myVals[5] = 99999999.99999999;
         myVals[6] = p;
         myVals[7] = op;
         myHashValue = hash((const unsigned char*)&myVals[0], sizeof(myVals));
      }
      
      DtIntersectorCacheKey(DtIntersector::IntersectProperties p, 
         DtIntersector::DynamicOceanProperties op, double x, double y, double z,
         double end_x, double end_y, double end_z)
      {
         myVals[0] = x; myVals[1] = y; myVals[2] = z;
         myVals[3] = end_x; myVals[4] = end_y; myVals[5] = end_z;
         myVals[6] = p;
         myVals[7] = op;
         myHashValue = hash((const unsigned char*)&myVals[0], sizeof(myVals));
      }

      DtIntersectorCacheKey(const DtIntersectorCacheKey& k)
      {
         memcpy(myVals, k.myVals, sizeof(myVals));
         myHashValue = k.myHashValue;
      }

      bool operator==(const DtIntersectorCacheKey& rhs) const
      {
         return (myHashValue == rhs.myHashValue);
      }

      bool operator!=(const DtIntersectorCacheKey& rhs) const
      {
         return !(*this == rhs);
      }

      std::size_t hash(const unsigned char *p, int n)
      {
          std::size_t h = 0;
          std::size_t g;

          while (n--) {
              h = (h << 4) + *p++;
              if ((g = (h & 0xf0000000)) != 0)
                  h ^= g >> 23;
              h &= ~g;
          }
          return h;
      }

      inline std::size_t hashValue() const
      {
         return myHashValue;
      }

      inline operator std::size_t() const
      {
         return myHashValue;
      }

   protected:
      double myVals[8];
      std::size_t myHashValue;
   };
}