vtkDICOMItem.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 vtkDICOMItem_h
#define vtkDICOMItem_h
 
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMDataElement.h"
#include "vtkDICOMDictEntry.h"
#include "vtkDICOMReferenceCount.h"
 
#include <string>
 
class vtkDICOMTagPath;
class vtkDICOMMetaData;
 
 
class VTKDICOM_EXPORT vtkDICOMItem
{
private:
 
  struct List
  {
    vtkDICOMDataElement Head;
    vtkDICOMDataElement Tail;
    vtkDICOMReferenceCount ReferenceCount;
    int NumberOfDataElements;
    vtkDICOMDataElement *DataElements;
    unsigned int ByteOffset;
    bool Delimited;
    vtkDICOMCharacterSet CharacterSet;
    vtkDICOMVR VRForXS;
 
    List() : Head(), Tail(), ReferenceCount(1),
             NumberOfDataElements(0), DataElements(nullptr),
             ByteOffset(0), Delimited(false),
             CharacterSet(vtkDICOMCharacterSet::ISO_IR_6),
             VRForXS(vtkDICOMVR::US) {}
  };
 
public:
 
  vtkDICOMItem() : L(nullptr) {}
 
 
  explicit vtkDICOMItem(vtkDICOMMetaData *meta);
 
 
  explicit vtkDICOMItem(
    vtkDICOMCharacterSet cs, vtkDICOMVR vrForXS,
    int delimited=0, unsigned int byteOffset=0);
 
  vtkDICOMItem(const vtkDICOMItem &o) : L(o.L) {
    if (this->L) { ++(this->L->ReferenceCount); } }
 
  ~vtkDICOMItem() { this->Clear(); }
 
  void Clear() {
    if (this->L && --(this->L->ReferenceCount) == 0) { this->FreeList(); }
    else { this->L = nullptr; } }
 
  bool IsEmpty() const { return (this->L == nullptr); }
 
  bool IsDelimited() const {
    return (this->L == nullptr || this->L->Delimited != 0); }
 
 
  void Set(vtkDICOMTag tag, const vtkDICOMValue& v);
  void Set(vtkDICOMTag tag, double v);
  void Set(vtkDICOMTag tag, const std::string& v);
  void SetAttributeValue(vtkDICOMTag tag, const vtkDICOMValue& v) {
    this->Set(tag, v); }
  void SetAttributeValue(vtkDICOMTag tag, double v) {
    this->Set(tag, v); }
  void SetAttributeValue(vtkDICOMTag tag, const std::string& v) {
    this->Set(tag, v); }
 
 
  void Set(const vtkDICOMTagPath& tag, const vtkDICOMValue& v);
  void Set(const vtkDICOMTagPath& tag, double v);
  void Set(const vtkDICOMTagPath& tag, const std::string& v);
  void SetAttributeValue(const vtkDICOMTagPath& tag, const vtkDICOMValue& v) {
    this->Set(tag, v); }
  void SetAttributeValue(const vtkDICOMTagPath& tag, double v) {
    this->Set(tag, v); }
  void SetAttributeValue(const vtkDICOMTagPath& tag, const std::string& v) {
    this->Set(tag, v); }
 
  const vtkDICOMValue &Get(vtkDICOMTag tag) const;
  const vtkDICOMValue &Get(const vtkDICOMTagPath &tag) const;
  const vtkDICOMValue &GetAttributeValue(vtkDICOMTag tag) const {
    return this->Get(tag); }
  const vtkDICOMValue &GetAttributeValue(const vtkDICOMTagPath &tag) const {
    return this->Get(tag); }
 
 
  unsigned int GetByteOffset() const {
    return (this->L == nullptr ? 0 : this->L->ByteOffset); }
 
  int GetNumberOfDataElements() const {
    return (this->L ? this->L->NumberOfDataElements : 0); }
 
  vtkDICOMDataElementIterator Begin() const {
    return (this->L ? this->L->Head.Next : nullptr); }
 
  vtkDICOMDataElementIterator End() const {
    return (this->L ? &this->L->Tail : nullptr); }
 
 
  vtkDICOMTag ResolvePrivateTag(
    vtkDICOMTag ptag, const std::string& creator) const;
 
 
  vtkDICOMTag ResolvePrivateTagForWriting(
    vtkDICOMTag ptag, const std::string& creator);
 
 
  vtkDICOMDictEntry FindDictEntry(vtkDICOMTag tag) const;
 
  vtkDICOMVR FindDictVR(vtkDICOMTag tag) const;
 
  bool operator==(const vtkDICOMItem& o) const;
  bool operator!=(const vtkDICOMItem& o) const {
    return !(*this == o); }
 
  vtkDICOMItem &operator=(const vtkDICOMItem &o) {
    if (this->L != o.L) {
      if (o.L) { ++(o.L->ReferenceCount); }
      if (this->L && --(this->L->ReferenceCount) == 0) { this->FreeList(); }
      this->L = o.L; }
    return *this; }
 
private:
  void FreeList();
  vtkDICOMDataElement *NewDataElement(vtkDICOMDataElement **iter);
  static void CopyList(const List *o, List *t);
  static void CopyDataElements(
    const vtkDICOMDataElement *begin, const vtkDICOMDataElement *end,
    List *t);
 
  vtkDICOMDataElement *FindDataElementOrInsert(vtkDICOMTag tag);
 
  vtkDICOMItem *FindItemOrInsert(
    const vtkDICOMTagPath& tagpath, vtkDICOMTag *tagptr);
 
  static const vtkDICOMValue InvalidValue;
 
  List *L;
};
 
#endif /* vtkDICOMItem_h */
// VTK-HeaderTest-Exclude: vtkDICOMItem.h