vtkDICOMDataElement.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 vtkDICOMDataElement_h
#define vtkDICOMDataElement_h
 
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMTag.h"
#include "vtkDICOMValue.h"
 
 
class VTKDICOM_EXPORT vtkDICOMDataElement
{
public:
  vtkDICOMDataElement() : Tag(), Value(), Next(nullptr), Prev(nullptr) {}
  vtkDICOMDataElement(const vtkDICOMTag& t, const vtkDICOMValue &v) :
    Tag(t), Value(v), Next(nullptr), Prev(nullptr) {}
 
  vtkDICOMTag GetTag() const { return this->Tag; }
 
  vtkDICOMVR GetVR() const { return this->Value.GetVR(); }
 
  bool IsPerInstance() const {
    return (this->Value.GetMultiplexData() != nullptr); }
 
  int GetNumberOfInstances() const {
    return static_cast<int>(this->Value.GetNumberOfValues()); }
 
  const vtkDICOMValue& GetValue() const { return this->Value; }
 
  const vtkDICOMValue& GetValue(int i) const {
    const vtkDICOMValue *vptr = this->Value.GetMultiplexData();
    return (vptr == nullptr ? this->Value : vptr[i]); }
 
  bool operator==(const vtkDICOMDataElement& o) const {
    return (this->Tag == o.Tag && this->Value == o.Value); }
 
  bool operator!=(const vtkDICOMDataElement& o) const {
    return (this->Tag != o.Tag || this->Value != o.Value); }
 
private:
  vtkDICOMTag          Tag;
  vtkDICOMValue        Value;
 
  // for storing elements in a linked list
  vtkDICOMDataElement *Next;
  vtkDICOMDataElement *Prev;
 
  // the classes that need to manipulate lists of elements
  friend class vtkDICOMDataElementIterator;
  friend class vtkDICOMMetaData;
  friend class vtkDICOMItem;
};
 
class VTKDICOM_EXPORT vtkDICOMDataElementIterator
{
public:
  vtkDICOMDataElementIterator() : Pointer(nullptr) {}
 
  vtkDICOMDataElementIterator& operator++() {
    if (this->Pointer) { this->Pointer = this->Pointer->Next; }
    return *this; }
 
  vtkDICOMDataElementIterator operator++(int) {
    const vtkDICOMDataElement *ptr = this->Pointer;
    if (ptr) { this->Pointer = this->Pointer->Next; }
    return vtkDICOMDataElementIterator(ptr); }
 
  vtkDICOMDataElementIterator& operator--() {
    if (this->Pointer) { this->Pointer = this->Pointer->Prev; }
    return *this; }
 
  vtkDICOMDataElementIterator operator--(int) {
    const vtkDICOMDataElement *ptr = this->Pointer;
    if (ptr) { this->Pointer = this->Pointer->Prev; }
    return vtkDICOMDataElementIterator(ptr); }
 
  const vtkDICOMDataElement *operator->() const { return this->Pointer; }
  const vtkDICOMDataElement& operator*() const { return *this->Pointer; }
 
  bool operator==(const vtkDICOMDataElementIterator& it) const {
    return (this->Pointer == it.Pointer); }
 
  bool operator!=(const vtkDICOMDataElementIterator& it) const {
    return (this->Pointer != it.Pointer); }
 
private:
  vtkDICOMDataElementIterator(const vtkDICOMDataElement *ptr) {
    this->Pointer = ptr; }
 
  const vtkDICOMDataElement *Pointer;
 
  friend class vtkDICOMMetaData;
  friend class vtkDICOMItem;
};
 
VTKDICOM_EXPORT ostream& operator<<(ostream& os, const vtkDICOMDataElement& v);
 
#endif /* vtkDICOMDataElement_h */
// VTK-HeaderTest-Exclude: vtkDICOMDataElement.h