itkXMLFile.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkXMLFile_h
#define itkXMLFile_h
#include "itkLightProcessObject.h"
#include "ITKIOXMLExport.h"
#include <fstream>
 
namespace itk
{
class ITKIOXML_EXPORT XMLReaderBase : public LightProcessObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(XMLReaderBase);
 
  using Self = XMLReaderBase;

  itkSetStringMacro(Filename);

  itkGetStringMacro(Filename);

  virtual int
  CanReadFile(const char * name) = 0;

  virtual void
  GenerateOutputInformation();

  virtual void
  StartElement(const char * name, const char ** atts) = 0;

  virtual void
  EndElement(const char * name) = 0;

  virtual void
  CharacterDataHandler(const char * inData, int inLength) = 0;
 
protected:
  XMLReaderBase() = default;
  ~XMLReaderBase() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  void
  parse();
 
  std::string m_Filename{};
};
class ITKIOXML_EXPORT XMLReaderBase : public LightProcessObject {…};

template <typename T>
class ITK_TEMPLATE_EXPORT XMLReader : public XMLReaderBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(XMLReader);
 
  using Self = XMLReader;

  void
  SetOutputObject(T * obj)
  {
    m_OutputObject = obj;
  }
  SetOutputObject(T * obj) {…}

  T *
  GetOutputObject()
  {
    return m_OutputObject;
  }
  GetOutputObject() {…}
 
protected:
  XMLReader()
    : m_OutputObject(nullptr)
  {}
  XMLReader() {…}
 
  ~XMLReader() override = default;
 
  T * m_OutputObject{};
};
class ITK_TEMPLATE_EXPORT XMLReader : public XMLReaderBase {…};

template <typename T>
class ITK_TEMPLATE_EXPORT XMLWriterBase : public LightProcessObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(XMLWriterBase);
 
  using Self = XMLWriterBase;

  XMLWriterBase() { m_InputObject = nullptr; }

  itkSetStringMacro(Filename);
  itkGetStringMacro(Filename);
  virtual int
  CanWriteFile(const char * name) = 0;

  void
  SetObject(T * toWrite)
  {
    m_InputObject = toWrite;
  }
  SetObject(T * toWrite) {…}

  virtual int
  WriteFile() = 0;
 
#if !defined(ITK_WRAPPING_PARSER)
  void
  WriteStartElement(const char * const tag, std::ofstream & file)
  {
    file << '<' << tag << '>';
  }
  WriteStartElement(const char * const tag, std::ofstream & file) {…}

  void
  WriteEndElement(const char * const tag, std::ofstream & file)
  {
    file << '<' << '/' << tag << '>';
  }
  WriteEndElement(const char * const tag, std::ofstream & file) {…}

  void
  WriteCharacterData(const char * const data, std::ofstream & file)
  {
    file << data;
  }
  WriteCharacterData(const char * const data, std::ofstream & file) {…}

  void
  WriteStartElement(std::string & tag, std::ofstream & file)
  {
    WriteStartElement(tag.c_str(), file);
  }
  WriteStartElement(std::string & tag, std::ofstream & file) {…}

  void
  WriteEndElement(std::string & tag, std::ofstream & file)
  {
    WriteEndElement(tag.c_str(), file);
  }
  WriteEndElement(std::string & tag, std::ofstream & file) {…}

  void
  WriteCharacterData(std::string & data, std::ofstream & file)
  {
    WriteCharacterData(data.c_str(), file);
  }
  WriteCharacterData(std::string & data, std::ofstream & file) {…}
#endif
 
protected:
  T *         m_InputObject{}; // object to write out to an XML file
  std::string m_Filename{};    // name of file to write.
};
class ITK_TEMPLATE_EXPORT XMLWriterBase : public LightProcessObject {…};
} // namespace itk
#endif