structaccess.h

Go to the documentation of this file.

// Copyright 2017-2020, Schlumberger
//
// 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.
 
#pragma once
 
#include "../declspec.h"
 
#include <array>
#include <sstream>
#include <iomanip>
#include <cstring>
#include <type_traits>
 
namespace InternalZGY { // namespace StructAccess {
#if 0
}
#endif
 
template<typename T, std::size_t N>
std::array<T, N>
ptr_to_array(const T* in)
{
  std::array<T, N> result;
  memcpy(result.data(), in, sizeof(result));
  return result;
}
 
template<typename T>
T align(const T& in)
{
  T result;
  memcpy(&result, &in, sizeof(T));
  return result;
}
 
template<typename T, std::size_t N>
std::string
array_to_string(const std::array<T, N>& a)
{
  std::stringstream ss;
  ss << "(";
  for (std::size_t ii=0; ii<N; ++ii)
    ss << std::to_string(a[ii]) << (ii == N-1 ? ")" : ", ");
  return ss.str();
}
 
template<typename T, std::size_t N>
std::string
array_to_hex(const std::array<T, N>& a)
{
  std::stringstream ss;
  ss << std::hex << std::setfill('0') << std::right;
  for (std::size_t ii=0; ii<N; ++ii)
    ss << std::setw(2*sizeof(T)) << int(a[ii]) << (ii==N-1 ? "" : ",");
  return ss.str();
}
 
template<typename T, std::size_t N>
std::string
ptr_to_string(const T* a)
{
  return array_to_hex<T, N>(ptr_to_array<T, N>(a));
}
 
template<typename T, std::size_t N>
std::string
ptr_to_hex(const T* a)
{
  return array_to_hex<T, N>(ptr_to_array<T, N>(a));
}
 
template<typename T>
static void
byteswapAlways(T *ptr, size_t n = 1)
{
  char in[sizeof(T)], out[sizeof(T)];
  for (size_t offset=0; offset<n; ++offset) {
    memcpy(&in[0], ptr, sizeof(T));
    for (size_t ii=0; ii<sizeof(T); ++ii)
      out[sizeof(T)-ii-1] = in[ii];
    memcpy(ptr, &out[0], sizeof(T));
    ++ptr;
  }
}
 
template<typename T>
static void
byteswapT(T *ptr, size_t n = 1)
{
#if BIG_ENDIAN_ARCH
  byteswapAlways(ptr, n);
#endif
}
 
extern OPENZGY_TEST_API void byteswapV1Long(std::int64_t *ptr, size_t n = 1);
 
extern OPENZGY_TEST_API void byteswapV1Long(std::uint64_t *ptr, size_t n = 1);
 
template<typename T, typename U, int N>
std::array<T,N>
array_cast(const std::array<U,N>& in)
{
  std::array<T,N> result;
  for (int ii=0; ii<N; ++ii)
    result[ii] = static_cast<T>(in[ii]);
  return result;
}
 
} // namespace