vtkMRMLNodePropertyMacros.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLNodePropertyMacros_h
#define __vtkMRMLNodePropertyMacros_h
 
#include <sstream> // needed for std::stringstream
#include <vtksys/SystemTools.hxx> // needed for vtksys::SystemTools functions
 
 
//----------------------------------------------------------------------------
 
#define vtkMRMLWriteXMLBeginMacro(of) \
  { \
  ostream& xmlWriteOutputStream = of;
 
#define vtkMRMLWriteXMLEndMacro() \
  }
 
#define vtkMRMLWriteXMLBooleanMacro(xmlAttributeName, propertyName) \
  xmlWriteOutputStream << " " #xmlAttributeName "=\"" << (Get##propertyName() ? "true" : "false") << "\"";
 
#define vtkMRMLWriteXMLStringMacro(xmlAttributeName, propertyName) \
  if (Get##propertyName() != nullptr) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    xmlWriteOutputStream << vtkMRMLNode::XMLAttributeEncodeString(Get##propertyName()); \
    xmlWriteOutputStream << "\""; \
  }
 
#define vtkMRMLWriteXMLStdStringMacro(xmlAttributeName, propertyName) \
  xmlWriteOutputStream << " " #xmlAttributeName "=\"" << vtkMRMLNode::XMLAttributeEncodeString(Get##propertyName().c_str()) << "\""; \
 
#define vtkMRMLWriteXMLEnumMacro(xmlAttributeName, propertyName) \
  xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
  if (Get##propertyName##AsString(Get##propertyName()) != nullptr) \
  { \
    xmlWriteOutputStream << vtkMRMLNode::XMLAttributeEncodeString(Get##propertyName##AsString(Get##propertyName())); \
  } \
  xmlWriteOutputStream << "\"";
 
#define vtkMRMLWriteXMLIntMacro(xmlAttributeName, propertyName) \
  xmlWriteOutputStream << " " #xmlAttributeName "=\"" << Get##propertyName() << "\"";
 
#define vtkMRMLWriteXMLFloatMacro(xmlAttributeName, propertyName) \
  xmlWriteOutputStream << " " #xmlAttributeName "=\"" << Get##propertyName() << "\"";
 
#define vtkMRMLWriteXMLVectorMacro(xmlAttributeName, propertyName, vectorType, vectorSize) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    vectorType* vectorPtr = Get##propertyName(); \
    if (vectorPtr != nullptr) \
    { \
      for (int i=0; i<vectorSize; i++) \
      { \
        if (i > 0) \
        { \
          xmlWriteOutputStream << " "; \
        } \
        xmlWriteOutputStream << vectorPtr[i]; \
      } \
    } \
    xmlWriteOutputStream << "\""; \
  }
 
#define vtkMRMLWriteXMLStdFloatVectorMacro(xmlAttributeName, propertyName, vectorType) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    vectorType vector = Get##propertyName(); \
    for (vectorType::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      xmlWriteOutputStream << *it; \
      xmlWriteOutputStream << " "; \
    } \
    xmlWriteOutputStream << "\""; \
  }
 
#define vtkMRMLWriteXMLStdIntVectorMacro(xmlAttributeName, propertyName, vectorType) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    vectorType vector = Get##propertyName(); \
    for (vectorType::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      xmlWriteOutputStream << *it; \
      xmlWriteOutputStream << " "; \
    } \
    xmlWriteOutputStream << "\""; \
  }
 
#define vtkMRMLWriteXMLStdStringVectorMacro(xmlAttributeName, propertyName, vectorType) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    vectorType<std::string> vector = Get##propertyName(); \
    for (vectorType<std::string>::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      if (it!=vector.begin()) \
      { \
        xmlWriteOutputStream << ";"; \
      } \
      std::string attributeValue = *it; \
      vtksys::SystemTools::ReplaceString(attributeValue, "%", "%25"); \
      vtksys::SystemTools::ReplaceString(attributeValue, ";", "%3B"); \
      xmlWriteOutputStream << vtkMRMLNode::XMLAttributeEncodeString(attributeValue); \
    } \
    xmlWriteOutputStream << "\""; \
  }
 
 
#define vtkMRMLWriteXMLMatrix4x4Macro(xmlAttributeName, propertyName) \
  { \
    xmlWriteOutputStream << " " #xmlAttributeName "=\""; \
    vtkMatrix4x4* matrix = this->Get##propertyName(); \
    for (int row = 0; row < 4; row++) \
    { \
      for (int col = 0; col < 4; col++) \
      { \
        of << matrix->GetElement(row, col); \
        if (!(row == 3 && col == 3)) \
        { \
          of << " "; \
        } \
      } \
    } \
    xmlWriteOutputStream << "\""; \
  }
 
 
//----------------------------------------------------------------------------
 
#define vtkMRMLReadXMLBeginMacro(atts) \
  { \
    const char* xmlReadAttName; \
    const char* xmlReadAttValue; \
    const char** xmlReadAtts = atts; \
    while (*xmlReadAtts != nullptr) \
    { \
      xmlReadAttName = *(xmlReadAtts++); \
      xmlReadAttValue = *(xmlReadAtts++); \
      if (xmlReadAttValue == nullptr) \
      { \
        break; \
      }
 
#define vtkMRMLReadXMLEndMacro() \
  }};
 
#define vtkMRMLReadXMLBooleanMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    this->Set##propertyName(strcmp(xmlReadAttValue,"true") ? false : true); \
  }
 
#define vtkMRMLReadXMLStringMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    this->Set##propertyName(xmlReadAttValue); \
  }
 
#define vtkMRMLReadXMLStdStringMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    this->Set##propertyName(xmlReadAttValue); \
  }
 
#define vtkMRMLReadXMLEnumMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    int propertyValue = this->Get##propertyName##FromString(xmlReadAttValue); \
    if (propertyValue >= 0) \
    { \
      this->Set##propertyName(propertyValue); \
    } \
    else \
    { \
      vtkErrorMacro("Failed to read " #xmlAttributeName " attribute value from string '" << xmlReadAttValue << "'"); \
    } \
  }
 
#define vtkMRMLReadXMLIntMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vtkVariant variantValue(xmlReadAttValue); \
    bool valid = false; \
    int intValue =  variantValue.ToInt(&valid); \
    if (valid) \
    { \
      this->Set##propertyName(intValue); \
    } \
    else \
    { \
      vtkErrorMacro("Failed to read " #xmlAttributeName " attribute value from string '" << xmlReadAttValue << "': integer expected"); \
    } \
  }
 
#define vtkMRMLReadXMLFloatMacro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vtkVariant variantValue(xmlReadAttValue); \
    bool valid = false; \
    double scalarValue =  variantValue.ToDouble(&valid); \
    if (valid) \
    { \
      this->Set##propertyName(scalarValue); \
    } \
    else \
    { \
      vtkErrorMacro("Failed to read " #xmlAttributeName " attribute value from string '" << xmlReadAttValue << "': float expected"); \
    } \
  }
 
#define vtkMRMLReadXMLVectorMacro(xmlAttributeName, propertyName, vectorType, vectorSize) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vectorType vectorValue[vectorSize] = {0}; \
    std::stringstream ss; \
    ss << xmlReadAttValue; \
    for (int i=0; i<vectorSize; i++) \
    { \
      vectorType val; \
      ss >> val; \
      vectorValue[i] = val; \
    } \
    this->Set##propertyName(vectorValue); \
  }
 
#define vtkMRMLReadXMLStdFloatVectorMacro(xmlAttributeName, propertyName, vectorType) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vectorType vector; \
    std::string valueString(xmlReadAttValue); \
    size_t separatorPosition = valueString.find(" "); \
    while(separatorPosition != std::string::npos) \
    { \
      std::string attributeValue = valueString.substr(0, separatorPosition); \
      vtkVariant variantValue(attributeValue); \
      bool valid = false; \
      vectorType::value_type scalarValue = variantValue.ToDouble(&valid); \
      if (valid) \
      { \
        vector.insert(vector.end(), scalarValue); \
      } \
      valueString = valueString.substr(separatorPosition+1); \
      separatorPosition = valueString.find(" "); \
    } \
    this->Set##propertyName(vector); \
  }
 
#define vtkMRMLReadXMLStdIntVectorMacro(xmlAttributeName, propertyName, vectorType) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vectorType vector; \
    std::string valueString(xmlReadAttValue); \
    size_t separatorPosition = valueString.find(" "); \
    while(separatorPosition != std::string::npos) \
    { \
      std::string attributeValue = valueString.substr(0, separatorPosition); \
      vtkVariant variantValue(attributeValue); \
      bool valid = false; \
      vectorType::value_type scalarValue = variantValue.ToInt(&valid); \
      if (valid) \
      { \
        vector.insert(vector.end(), scalarValue); \
      } \
      valueString = valueString.substr(separatorPosition+1); \
      separatorPosition = valueString.find(" "); \
    } \
    this->Set##propertyName(vector); \
  }
 
#define vtkMRMLReadXMLStdStringVectorMacro(xmlAttributeName, propertyName, vectorType) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vectorType<std::string> attributeValues; \
    std::string valueString(xmlReadAttValue); \
    std::vector<std::string> splitXmlReadAttValue = vtksys::SystemTools::SplitString(valueString, ';'); \
    for (std::string attributeValue : splitXmlReadAttValue) \
    { \
      vtksys::SystemTools::ReplaceString(attributeValue, "%3B", ";"); \
      vtksys::SystemTools::ReplaceString(attributeValue, "%25", "%"); \
      attributeValues.emplace_back(attributeValue); \
    } \
    this->Set##propertyName(attributeValues); \
  }
 
#define vtkMRMLReadXMLOwnedMatrix4x4Macro(xmlAttributeName, propertyName) \
  if (!strcmp(xmlReadAttName, #xmlAttributeName)) \
  { \
    vtkNew<vtkMatrix4x4> matrix; \
    std::stringstream ss; \
    double val; \
    ss << xmlReadAttValue; \
    for (int row = 0; row < 4; row++) \
    { \
      for (int col = 0; col < 4; col++) \
      { \
        ss >> val; \
        matrix->SetElement(row, col, val); \
      }  \
    }  \
    this->Get##propertyName()->DeepCopy(matrix); \
  }
 
 
//----------------------------------------------------------------------------
 
#define vtkMRMLCopyBeginMacro(sourceNode) \
  { \
    vtkMRMLNode* copySourceNode = this->SafeDownCast(sourceNode); \
    if (copySourceNode != nullptr) \
    {
 
#define vtkMRMLCopyEndMacro() \
    } \
    else \
    { \
      vtkErrorMacro("Copy failed: invalid source node"); \
    } \
  }
 
#define vtkMRMLCopyBooleanMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyStringMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyStdStringMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyIntMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyEnumMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyFloatMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyVectorMacro(propertyName, vectorType, vectorSize) \
    { \
      /* Currently, vectorType and vectorSize is not essential, but in the future */ \
      /* this information may be used more. */ \
      vectorType* sourceVector = this->SafeDownCast(copySourceNode)->Get##propertyName(); \
      if (sourceVector != nullptr) \
      { \
        this->Set##propertyName(sourceVector); \
      } \
      else \
      { \
        vtkErrorMacro("Failed to copy " #propertyName " attribute value: source node returned NULL"); \
      } \
    }
 
#define vtkMRMLCopyStdFloatVectorMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyStdIntVectorMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyStdStringVectorMacro(propertyName) \
  this->Set##propertyName(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
#define vtkMRMLCopyOwnedMatrix4x4Macro(propertyName) \
   this->Get##propertyName()->DeepCopy(this->SafeDownCast(copySourceNode)->Get##propertyName());
 
 
//----------------------------------------------------------------------------
 
#define vtkMRMLPrintBeginMacro(os, indent) \
  { \
    ostream& printOutputStream = os; \
    vtkIndent printOutputIndent = indent;
 
#define vtkMRMLPrintEndMacro() \
  }
 
#define vtkMRMLPrintBooleanMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << (this->Get##propertyName() ? "true" : "false")  << "\n";
 
#define vtkMRMLPrintStringMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << (this->Get##propertyName() != nullptr ? this->Get##propertyName() : "(none)")  << "\n";
 
#define vtkMRMLPrintStdStringMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << this->Get##propertyName() << "\n";
 
#define vtkMRMLPrintEnumMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << (Get##propertyName##AsString(Get##propertyName()))  << "\n";
 
#define vtkMRMLPrintIntMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << this->Get##propertyName() << "\n";
 
#define vtkMRMLPrintFloatMacro(propertyName) \
  printOutputStream << printOutputIndent << #propertyName ": " << this->Get##propertyName() << "\n";
 
#define vtkMRMLPrintVectorMacro(propertyName, vectorType, vectorSize) \
  { \
  printOutputStream << printOutputIndent << #propertyName ": ("; \
  vectorType* vectorValue = this->Get##propertyName(); \
  if (vectorValue) \
  { \
    for (int i=0; i<vectorSize; i++) \
    { \
      if (i > 0) \
      { \
        printOutputStream << ", "; \
      } \
      printOutputStream << vectorValue[i]; \
    } \
    printOutputStream << ")\n"; \
  } \
  }
 
#define vtkMRMLPrintStdFloatVectorMacro(propertyName, vectorType) \
  { \
    printOutputStream << printOutputIndent << #propertyName " : ("; \
    vectorType vector = this->Get##propertyName(); \
    for (vectorType::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      if (it != vector.begin()) \
      { \
        printOutputStream << ", "; \
      } \
      printOutputStream << *it; \
    } \
    printOutputStream << ")\n"; \
  }
 
#define vtkMRMLPrintStdIntVectorMacro(propertyName, vectorType) \
  { \
    printOutputStream << printOutputIndent << #propertyName " : ("; \
    vectorType vector = this->Get##propertyName(); \
    for (vectorType::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      if (it != vector.begin()) \
      { \
        printOutputStream << ", "; \
      } \
      printOutputStream << *it; \
    } \
    printOutputStream << ")\n"; \
  }
 
#define vtkMRMLPrintStdStringVectorMacro(propertyName, vectorType) \
  { \
    printOutputStream << printOutputIndent << #propertyName " : (\""; \
    vectorType<std::string> vector = this->Get##propertyName(); \
    for (vectorType<std::string>::iterator it=vector.begin(); it!=vector.end(); it++) \
    { \
      if (it != vector.begin()) \
      { \
        printOutputStream << "\", \""; \
      } \
      printOutputStream << *it; \
    } \
    printOutputStream << "\")\n"; \
  }
 
#define vtkMRMLPrintMatrix4x4Macro(propertyName) \
  { \
    vtkMatrix4x4* matrix = this->Get##propertyName(); \
    printOutputStream << printOutputIndent << #propertyName ":"; \
    if (matrix) \
    { \
      printOutputStream << "\n"; \
      matrix->PrintSelf(printOutputStream, printOutputIndent.GetNextIndent()); \
    } \
    else \
    { \
      printOutputStream << " (none)\n"; \
    } \
  }
 
#define vtkMRMLPrintObjectMacro(propertyName) \
  { \
    vtkObject* obj = this->Get##propertyName(); \
    printOutputStream << printOutputIndent << #propertyName ":"; \
    if (obj) \
    { \
      printOutputStream << "\n"; \
      obj->PrintSelf(printOutputStream, printOutputIndent.GetNextIndent()); \
    } \
    else \
    { \
      printOutputStream << " (none)\n"; \
    } \
  }
 
 
 
#endif