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 << " "; \
          } \
        } \
      if (row != 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 // __vtkMRMLNodePropertyMacros_h