OCCT

// Created on: 2005-10-05
// Created by: Mikhail KLOKOV
// Copyright (c) 2005-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <Standard_HashUtils.hxx>

inline void IntTools_SurfaceRangeSample::SetRanges(const IntTools_CurveRangeSample& theRangeU,
                                                   const IntTools_CurveRangeSample& theRangeV)
{
  myRangeU = theRangeU;
  myRangeV = theRangeV;
}

inline void IntTools_SurfaceRangeSample::GetRanges(IntTools_CurveRangeSample& theRangeU,
                                                   IntTools_CurveRangeSample& theRangeV) const
{
  theRangeU = myRangeU;
  theRangeV = myRangeV;
}

inline void IntTools_SurfaceRangeSample::SetIndexes(const int theIndexU, const int theIndexV)
{
  myRangeU.SetRangeIndex(theIndexU);
  myRangeV.SetRangeIndex(theIndexV);
}

inline void IntTools_SurfaceRangeSample::GetIndexes(int& theIndexU, int& theIndexV) const
{
  theIndexU = myRangeU.GetRangeIndex();
  theIndexV = myRangeV.GetRangeIndex();
}

inline void IntTools_SurfaceRangeSample::GetDepths(int& theDepthU, int& theDepthV) const
{
  theDepthU = myRangeU.GetDepth();
  theDepthV = myRangeV.GetDepth();
}

inline void IntTools_SurfaceRangeSample::SetSampleRangeU(
  const IntTools_CurveRangeSample& theRangeSampleU)
{
  myRangeU = theRangeSampleU;
}

inline const IntTools_CurveRangeSample& IntTools_SurfaceRangeSample::GetSampleRangeU() const
{
  return myRangeU;
}

inline void IntTools_SurfaceRangeSample::SetSampleRangeV(
  const IntTools_CurveRangeSample& theRangeSampleV)
{
  myRangeV = theRangeSampleV;
}

inline const IntTools_CurveRangeSample& IntTools_SurfaceRangeSample::GetSampleRangeV() const
{
  return myRangeV;
}

inline void IntTools_SurfaceRangeSample::SetIndexU(const int theIndexU)
{
  myRangeU.SetRangeIndex(theIndexU);
}

inline int IntTools_SurfaceRangeSample::GetIndexU() const
{
  return myRangeU.GetRangeIndex();
}

inline void IntTools_SurfaceRangeSample::SetIndexV(const int theIndexV)
{
  myRangeV.SetRangeIndex(theIndexV);
}

inline int IntTools_SurfaceRangeSample::GetIndexV() const
{
  return myRangeV.GetRangeIndex();
}

inline void IntTools_SurfaceRangeSample::SetDepthU(const int theDepthU)
{
  myRangeU.SetDepth(theDepthU);
}

inline int IntTools_SurfaceRangeSample::GetDepthU() const
{
  return myRangeU.GetDepth();
}

inline void IntTools_SurfaceRangeSample::SetDepthV(const int theDepthV)
{
  myRangeV.SetDepth(theDepthV);
}

inline int IntTools_SurfaceRangeSample::GetDepthV() const
{
  return myRangeV.GetDepth();
}

inline bool IntTools_SurfaceRangeSample::IsEqual(const IntTools_SurfaceRangeSample& Other) const
{
  return (myRangeU.IsEqual(Other.myRangeU) && myRangeV.IsEqual(Other.myRangeV));
}

inline int IntTools_SurfaceRangeSample::GetRangeIndexUDeeper(const int theNbSampleU) const
{
  return myRangeU.GetRangeIndexDeeper(theNbSampleU);
}

inline int IntTools_SurfaceRangeSample::GetRangeIndexVDeeper(const int theNbSampleV) const
{
  return myRangeV.GetRangeIndexDeeper(theNbSampleV);
}

namespace std
{
template <>
struct hash<IntTools_SurfaceRangeSample>
{
  size_t operator()(const IntTools_SurfaceRangeSample& theSurfaceRangeSample) const noexcept
  {
    // Combine two int values into a single hash value.
    size_t aCombination[2]{
      std::hash<IntTools_CurveRangeSample>{}(theSurfaceRangeSample.GetSampleRangeU()),
      std::hash<IntTools_CurveRangeSample>{}(theSurfaceRangeSample.GetSampleRangeV())};
    return opencascade::hashBytes(aCombination, sizeof(aCombination));
  }
};
} // namespace std