vtkMRMLJsonElement.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  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 vtkMRMLJsonElement_h
#define vtkMRMLJsonElement_h
 
#include "vtkMRMLMessageCollection.h"
#include "vtkSmartPointer.h"
#include "vtkNew.h"
 
#include <vector>
 
class vtkCodedEntry;
class vtkXMLDataElement;

class VTK_MRML_EXPORT vtkMRMLJsonElement : public vtkObject
{
public:
  static vtkMRMLJsonElement* New();
  vtkTypeMacro(vtkMRMLJsonElement, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  // Separator characters for (de)serializing the UID and the attributes map
  static const std::string XML_SEPARATOR;
  static const std::string XML_NAME_VALUE_SEPARATOR;

  std::string GetSchema();

  bool HasMember(const char* propertyName);
 
  enum Type
  {
    UNKNOWN = 0,
    OBJECT = 1,
    ARRAY = 2,
    STRING = 3,
    BOOL = 4,
    INT = 5,
    DOUBLE = 6
  };
  Type GetMemberType(const char* propertyName);

  std::string GetStringProperty(const char* propertyName);
  bool GetStringProperty(const char* propertyName, std::string& propertyValue);

  bool GetBoolProperty(const char* propertyName);
  bool GetBoolProperty(const char* propertyName, bool& propertyValue);

  bool GetDoubleProperty(const char* propertyName, double& propertyValue);

  double GetDoubleProperty(const char* propertyName);

  bool GetIntProperty(const char* propertyName, int& propertyValue);

  int GetIntProperty(const char* propertyName);

  bool GetVectorProperty(const char* propertyName, double* v, int numberOfComponents = 3);

  bool GetMatrix4x4Property(const char* propertyName, double v[16], bool flipRasLps);

  bool GetStringVectorProperty(const char* propertyName, std::vector<std::string>& arrayValues);

  VTK_NEWINSTANCE
  vtkCodedEntry* GetCodedEntryProperty(const char* propertyName);

  VTK_NEWINSTANCE
  vtkDoubleArray* GetDoubleArrayProperty(const char* propertyName);

  bool GetArrayItemsStringProperty(const char* arrayName, const char* propertyName, std::vector<std::string>& propertyValues);

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* GetArrayProperty(const char* arrayName);

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* GetObjectProperty(const char* objectName);

  bool IsArray();

  int GetArraySize();

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* GetArrayItem(int childItemIndex);

  bool IsObject();

  int GetObjectSize();

  std::string GetObjectPropertyNameByIndex(int childItemIndex);

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* GetObjectItem(int childItemIndex);

  Type GetType();

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* GetChildMemberItem(int childItemIndex);

  vtkGetObjectMacro(UserMessages, vtkMRMLMessageCollection);

  bool HasErrors();
 
protected:
  vtkMRMLJsonElement();
  ~vtkMRMLJsonElement() override;
  vtkMRMLJsonElement(const vtkMRMLJsonElement&);
  void operator=(const vtkMRMLJsonElement&);
 
  vtkNew<vtkMRMLMessageCollection> UserMessages;
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;
  friend class vtkMRMLJsonReader;
};
 
class VTK_MRML_EXPORT vtkMRMLJsonReader : public vtkObject
{
public:
  static vtkMRMLJsonReader* New();
  vtkTypeMacro(vtkMRMLJsonReader, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* ReadFromFile(const char* filePath);

  VTK_NEWINSTANCE
  vtkMRMLJsonElement* ReadFromString(const std::string& jsonString);

  std::string ConvertJsonToXML(const std::string& jsonString, const std::string& nodeTagName);

  vtkGetObjectMacro(UserMessages, vtkMRMLMessageCollection);

  bool HasErrors();
 
protected:
  vtkMRMLJsonReader();
  ~vtkMRMLJsonReader() override;
  vtkMRMLJsonReader(const vtkMRMLJsonReader&);
  void operator=(const vtkMRMLJsonReader&);
 
  std::string processJsonElement(vtkMRMLJsonElement* jsonElement, const std::string& elementKey = "");
 
  vtkNew<vtkMRMLMessageCollection> UserMessages;
};

class VTK_MRML_EXPORT vtkMRMLJsonWriter : public vtkObject
{
public:
  static vtkMRMLJsonWriter* New();
  vtkTypeMacro(vtkMRMLJsonWriter, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  bool WriteToFileBegin(const char* filePath, const char* schema);

  bool WriteToFileEnd();

  bool WriteToStringBegin(const char* nodeTagName);

  std::string WriteToStringEnd();

  void WriteArrayPropertyStart(const std::string& propertyName);
  void WriteArrayPropertyEnd();

  void WriteObjectStart();
  void WriteObjectEnd();

  void WriteObjectPropertyStart(const std::string& propertyName);
  void WriteObjectPropertyEnd();

  void WriteStringProperty(const std::string& propertyName, const std::string& propertyValue);
  void WriteStringVectorProperty(const std::string& propertyName, const std::vector<std::string>& arrayValues);
  void WriteCodedEntryProperty(const std::string& propertyName, vtkCodedEntry* codedEntry);
  void WriteStringPropertyIfNotEmpty(const std::string& propertyName, const std::string& propertyValue);
  void WriteBoolProperty(const std::string& propertyName, bool propertyValue);
  void WriteIntProperty(const std::string& propertyName, int propertyValue);
  void WriteDoubleProperty(const std::string& propertyName, double propertyValue);
  void WriteVectorProperty(const std::string& propertyName, double* v, int numberOfComponents = 3);
  void WriteMatrix4x4Property(const std::string& propertyName, double v[16], bool flipRasLps);
  void WriteDoubleArrayProperty(const char* propertyName, vtkDoubleArray* doubleArray);

  std::string toLower(const std::string& str);
  bool isBool(const std::string& str);
  bool isInt(const std::string& str);
  bool isDouble(const std::string& str);

  std::string ConvertXMLToJson(vtkXMLDataElement* xmlElement, const std::string& nodeTagName);

  vtkGetObjectMacro(UserMessages, vtkMRMLMessageCollection);

  bool HasErrors();
 
protected:
  vtkMRMLJsonWriter();
  ~vtkMRMLJsonWriter() override;
  vtkMRMLJsonWriter(const vtkMRMLJsonWriter&);
  void operator=(const vtkMRMLJsonWriter&);
 
  void processXMLElement(vtkXMLDataElement* xmlElement);
 
  vtkNew<vtkMRMLMessageCollection> UserMessages;
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;
};
 
#endif