WEMPersistenceHelper.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2015, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "MLWEMIncludes.h"
#include "WEMPrimitive.h"
 
#include <cstring>
 
ML_START_NAMESPACE
 
namespace WEMPersistenceHelper
{
  bool isWEMFormatIdentifier(const std::string& wemIdentifier);
}
 
class FileMapReadOutOfBoundsException
{
public:
  FileMapReadOutOfBoundsException() {}
};
 
class FileMapWrapper
{
public:
  FileMapWrapper(MLuint64 filesize, char* startAddress);
 
 
  template <typename DT> DT readValueFromMapAhead()
  {
    static_assert(std::is_integral_v<DT> || std::is_floating_point_v<DT>, "Only integral or floating point types are currently supported.");
 
    DT value;
 
    if constexpr (std::is_same_v<DT, bool>)
    {
      const auto *tmp = getCurrentAddress(1);
      value = *tmp != '\0';
    }
    else
    {
      memcpy(&value, getCurrentAddress(sizeof(DT)), sizeof(DT));
      if (_swapBytes)
      {
        MLSwapBytes(reinterpret_cast<unsigned char *>(&value), sizeof(DT), sizeof(DT));
      }
    }
    return value;
  }
 
  
  template <typename DT>
  DT readValueFromMap()
  {
    auto value = readValueFromMapAhead<DT>();
    static_assert(!std::is_same_v<DT, bool> || sizeof(bool) == 1, "Sizeof bool is expected to be 1!");
    _currentAddress += sizeof(DT);
    return value;
  }
 
  void readStringFromMap(std::string& value, size_t stringLength);
  void readStringWithSizeFromMap(std::string& value);
  void readVector3FromMap(Vector3& value, size_t byteSize);
  void readVector4FromMap(Vector4& value, size_t byteSize);
 
  const char* getInitialAddress() const { return _initialAddress; }
  const char* getCurrentAddress() const { return _currentAddress; }
  const char* getCurrentAddress(size_t byteSize);
 
  void advance(size_t byteSize);
  MLuint64 getNumBytesRead() const;
  void setSwapBytes(bool swapBytes)
  {
    _swapBytes = swapBytes;
  }
 private:
  bool _readValueWillBeWithinFileMapping(size_t byteSize) const;
 
  const MLuint64 _filesize;
  const char* const _initialAddress;
  char* _currentAddress;
  const char* const _endAddress;
  bool _swapBytes;
};
 
 
class OutStreamWrapper
{
public:
  OutStreamWrapper(std::ostream& outstream);
 
  template <typename DT>
  void writeValueToStream(const DT& value, size_t byteSize)
  {
    outstream->write(reinterpret_cast<const char*>(&value), byteSize);
  }
 
  void writePrimitiveIdToStream(WEMPrimitive* primitive);
  void writeStringToStream(const std::string& value);
  void writeStringWithSizeToStream(const std::string& value);
 
private:
  std::ostream* outstream;
};
 
 
 
ML_END_NAMESPACE