vtkDICOMValue.h

/*=========================================================================
 
  Program: DICOM for VTK
 
  Copyright (c) 2012-2024 David Gobbi
  All rights reserved.
  See Copyright.txt or http://dgobbi.github.io/bsd3.txt for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkDICOMValue_h
#define vtkDICOMValue_h
 
#include "vtkSystemIncludes.h"
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMVR.h"
#include "vtkDICOMTag.h"
#include "vtkDICOMCharacterSet.h"
#include "vtkDICOMReferenceCount.h"
 
#include <string>
 
// type constants
#define VTK_DICOM_TAG    13
#define VTK_DICOM_ITEM   14
#define VTK_DICOM_VALUE  15
 
// This adds an overflow byte for the "NumberOfValues" field, so that
// "NumberOfValues" can effectively go as high as 2^40-1.  This means
// that data elements that use delimiters, rather than fixed lengths,
// can store up to one terabyte instead of being limited to four gigabytes.
#if defined(__x86_64__) || defined(__ia64__) || defined(_M_X64)
#define VTK_DICOM_USE_OVERFLOW_BYTE
#endif
 
class vtkDICOMItem;
class vtkDICOMSequence;
 
 
class VTKDICOM_EXPORT vtkDICOMValue
{
private:
  struct Value
  {
    vtkDICOMReferenceCount ReferenceCount;
    unsigned char  Type;
    unsigned char  CharacterSet;
    unsigned char  Overflow;
    vtkDICOMVR     VR;
    unsigned int   VL;
    unsigned int   NumberOfValues;
 
    Value() : ReferenceCount(1) {}
  };
 
  template<class T>
  struct ValueT : Value
  {
    T Data[1];
 
    ValueT(vtkDICOMVR vr, size_t vn);
    static bool Compare(const Value *a, const Value *b);
    static bool CompareEach(const Value *a, const Value *b);
  };
 
public:
 
 
  vtkDICOMValue(vtkDICOMVR vr, double v);
  vtkDICOMValue(vtkDICOMVR vr, const std::string& v);
  vtkDICOMValue(vtkDICOMVR vr, vtkDICOMTag v);
  vtkDICOMValue(vtkDICOMVR vr, const vtkDICOMItem& v);
  vtkDICOMValue(vtkDICOMVR vr, const char *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const unsigned char *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const short *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const unsigned short *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const int *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const unsigned int *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const long long *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const unsigned long long *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const float *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const double *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const vtkDICOMTag *data, size_t count);
  vtkDICOMValue(vtkDICOMVR vr, const vtkDICOMItem *data, size_t count);
 
 
  vtkDICOMValue(vtkDICOMVR vr, vtkDICOMCharacterSet cs,
                const std::string& v);
  vtkDICOMValue(vtkDICOMVR vr, vtkDICOMCharacterSet cs,
                const char *data, size_t l);
 
  explicit vtkDICOMValue(vtkDICOMVR vr);
 
  vtkDICOMValue(const vtkDICOMValue &v) : V(v.V) {
    if (this->V) { ++(this->V->ReferenceCount); } }
 
  vtkDICOMValue(vtkDICOMTag v);
 
  vtkDICOMValue(const vtkDICOMItem &v);
 
  vtkDICOMValue(const vtkDICOMSequence &v);
 
  vtkDICOMValue() : V(nullptr) {}
 
  ~vtkDICOMValue() { this->Clear(); }
 
 
  static vtkDICOMValue FromUTF8String(
    vtkDICOMVR vr, vtkDICOMCharacterSet cs, const std::string& v);
 
  void Clear() {
    if (this->V && --(this->V->ReferenceCount) == 0) {
      this->FreeValue(this->V); }
    this->V = nullptr; }
 
  bool IsValid() const { return (this->V != nullptr); }
 
  vtkDICOMVR GetVR() const { return (this->V ? this->V->VR : vtkDICOMVR()); }
 
  unsigned int GetVL() const { return (this->V ? this->V->VL : 0); }
 
 
  vtkDICOMCharacterSet GetCharacterSet() const {
    return (this->V ? this->V->CharacterSet : 0); }
 
 
  size_t GetNumberOfValues() const {
    return (this->V ? this->V->NumberOfValues
#ifdef VTK_DICOM_USE_OVERFLOW_BYTE
            + (static_cast<size_t>(this->V->Overflow) << 32)
#endif
            : 0); }
 
 
  void GetValues(std::string *vb, size_t n, size_t i=0) const;
  void GetValues(unsigned char *vb, size_t n, size_t i=0) const;
  void GetValues(short *vb, size_t n, size_t i=0) const;
  void GetValues(unsigned short *vb, size_t n, size_t i=0) const;
  void GetValues(int *vb, size_t n, size_t i=0) const;
  void GetValues(unsigned int *vb, size_t n, size_t i=0) const;
  void GetValues(long long *vb, size_t n, size_t i=0) const;
  void GetValues(unsigned long long *vb, size_t n, size_t i=0) const;
  void GetValues(float *vb, size_t n, size_t i=0) const;
  void GetValues(double *vb, size_t n, size_t i=0) const;
  void GetValues(vtkDICOMTag *vb, size_t n, size_t i=0) const;
 
 
  std::string GetUTF8String(size_t i) const;
  std::string GetString(size_t i) const;
  unsigned char GetUnsignedChar(size_t i) const;
  short GetShort(size_t i) const;
  unsigned short GetUnsignedShort(size_t i) const;
  int GetInt(size_t i) const;
  unsigned int GetUnsignedInt(size_t i) const;
  long long GetInt64(size_t i) const;
  unsigned long long GetUnsignedInt64(size_t i) const;
  float GetFloat(size_t i) const;
  double GetDouble(size_t i) const;
  vtkDICOMTag GetTag(size_t i) const;
  const vtkDICOMItem& GetItem(size_t i) const;
 
 
  std::string AsUTF8String() const;
  std::string AsString() const;
  unsigned char AsUnsignedChar() const;
  short AsShort() const;
  unsigned short AsUnsignedShort() const;
  int AsInt() const;
  unsigned int AsUnsignedInt() const;
  long long AsInt64() const;
  unsigned long long AsUnsignedInt64() const;
  float AsFloat() const;
  double AsDouble() const;
  vtkDICOMTag AsTag() const;
  const vtkDICOMItem& AsItem() const;
 
 
  const char *GetCharData() const;
  const unsigned char *GetUnsignedCharData() const;
  const short *GetShortData() const;
  const unsigned short *GetUnsignedShortData() const;
  const int *GetIntData() const;
  const unsigned int *GetUnsignedIntData() const;
  const long long *GetInt64Data() const;
  const unsigned long long *GetUnsignedInt64Data() const;
  const float *GetFloatData() const;
  const double *GetDoubleData() const;
  const vtkDICOMTag *GetTagData() const;
  const vtkDICOMItem *GetSequenceData() const;
  const vtkDICOMValue *GetMultiplexData() const;
 
 
  char *AllocateCharData(vtkDICOMVR vr, size_t vn);
  char *AllocateCharData(
    vtkDICOMVR vr, vtkDICOMCharacterSet cs, size_t vn);
  unsigned char *AllocateUnsignedCharData(vtkDICOMVR vr, size_t vn);
  short *AllocateShortData(vtkDICOMVR vr, size_t vn);
  unsigned short *AllocateUnsignedShortData(vtkDICOMVR vr, size_t vn);
  int *AllocateIntData(vtkDICOMVR vr, size_t vn);
  unsigned int *AllocateUnsignedIntData(vtkDICOMVR vr, size_t vn);
  long long *AllocateInt64Data(vtkDICOMVR vr, size_t vn);
  unsigned long long *AllocateUnsignedInt64Data(vtkDICOMVR vr, size_t vn);
  float *AllocateFloatData(vtkDICOMVR vr, size_t vn);
  double *AllocateDoubleData(vtkDICOMVR vr, size_t vn);
  vtkDICOMTag *AllocateTagData(vtkDICOMVR vr, size_t vn);
  vtkDICOMItem *AllocateSequenceData(vtkDICOMVR vr, size_t vn);
  vtkDICOMValue *AllocateMultiplexData(vtkDICOMVR vr, size_t vn);
 
 
  void ComputeNumberOfValuesForCharData();
 
 
  unsigned char *ReallocateUnsignedCharData(size_t vn);
 
  /*
   *  String values will be converted from their native encoding
   *  to UTF-8.
   */
  void AppendValueToUTF8String(std::string &str, size_t i) const;
 
  /*
   *  This method will check for control characters or unconvertible
   *  characters in the value, and will replace them with four-byte
   *  codes of the form '\ooo' where 'o' is an octal digit.
   */
  void AppendValueToSafeUTF8String(std::string &str, size_t i) const;
 
 
  void AppendValueToString(std::string &str, size_t i) const;
 
 
  bool Matches(const vtkDICOMValue& value) const;
 
 
  bool Matches(const std::string& v) const;
 
 
  bool Matches(double v) const;
 
  vtkDICOMValue& operator=(const vtkDICOMValue& o) {
    if (this->V != o.V) {
      if (o.V) { ++(o.V->ReferenceCount); }
      if (this->V) {
        if (--(this->V->ReferenceCount) == 0) { this->FreeValue(this->V); } }
      this->V = o.V; }
    return *this; }
 
  vtkDICOMValue& operator=(const vtkDICOMSequence& o);
 
  bool operator==(const vtkDICOMValue& o) const;
  bool operator!=(const vtkDICOMValue& o) const { return !(*this == o); }
 
private:
  template<class T>
  T *Allocate(vtkDICOMVR vr, size_t vn);
 
  static void FreeValue(Value *v);
 
  template<class OT>
  void GetValuesT(OT *v, size_t count, size_t s) const;
 
  template<class T>
  void CreateValue(vtkDICOMVR vr, const T *data, size_t count);
 
  template<class T>
  void AppendInit(vtkDICOMVR vr);
 
  template<class T>
  void AppendValue(const T &item);
 
  template<class T>
  void SetValue(size_t i, const T &item);
 
  vtkDICOMValue *GetMultiplex();
 
  void Substring(size_t i, const char *&start, const char *&end) const;
 
  void CreateValueWithSpecificCharacterSet(
    vtkDICOMVR vr, vtkDICOMCharacterSet cs, const char *data, size_t l);
 
 
  size_t CreateValueFromUTF8(
    vtkDICOMVR vr, vtkDICOMCharacterSet cs, const char *data, size_t l);
 
  static bool PatternMatches(
    const char *pattern, const char *pe, const char *val, const char *ve);
 
  static bool PatternMatchesMulti(
    const char *pattern, const char *val, vtkDICOMVR vr);
 
 
  static size_t NormalizeDateTime(
    const char *input, char output[22], vtkDICOMVR vr);
 
 
  static bool PatternMatchesPersonName(const char *pattern, const char *val);
 
 
  static void NormalizePersonName(
    const char *input, char output[256], bool isquery=false);
 
  Value *V;
 
  static const vtkDICOMItem EmptyItem;
 
  // friend the sequence class, it requires AppendValue() and SetValue().
  friend class vtkDICOMSequence;
 
  // friend the meta data class, it requires GetMultiplex().
  friend class vtkDICOMValueFriendMetaData;
};
 
// This friendship class allows vtkDICOMMetaData to use exactly one
// private method from vtkDICOMValue.
class vtkDICOMValueFriendMetaData
{
  static vtkDICOMValue *GetMultiplex(vtkDICOMValue *v) {
    return v->GetMultiplex(); }
 
  friend class vtkDICOMMetaData;
};
 
VTKDICOM_EXPORT ostream& operator<<(ostream& os, const vtkDICOMValue& v);
 
#endif /* vtkDICOMValue_h */
// VTK-HeaderTest-Exclude: vtkDICOMValue.h