Utml.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef UTQML_HPP
#define UTQML_HPP
#include <cassert>
#include <exception>
#include <iosfwd>
#include <map>
#include <string>
#include <vector>
 
#include "WsfUtExport.hpp"
 
 
class UtTextDocument;
 
/* 'Utml' is a simple text file format and associated DOM which looks like a simplified QML
               see http://en.wikipedia.org/wiki/QML
   - There is no javascript
   - There are no special value types
   - There are no lists, aka, '[ ... ]'
 
  Example:
 
  // comments are like this
  // Define an object of type 'Widget'
  // Object types must begin with a capital letter
  Widget {
     // Any number of named properties can be set
     // properties begin with a lower-case letter
     id:    foo
     width: 5 meters
     info:  "arbitrary strings
   can be inserted between
      quotes.  Embed quotes like ""this"" "
     stuff: single line text can be used without quotes
 
     // Objects may contain other objects, not connected to any property
     Part {
       id: part1
     }
     Part {
       id: part2
     }
 
     object_property: Part {
       // property values can be objects too
       id: part3
     }
 
  }
 
*/
 
class UtmlParserP;
 
class WSF_UT_EXPORT UtmlParseError : public std::exception
{
public:
   UtmlParseError(const std::string& aError);
   ~UtmlParseError() override;
   const char* what() const noexcept override;
 
   std::string mError;
};
 
// An object in a UTML document, or a simple value.
// if IsContainer() is true, this represents an object with this syntax:
// <TypeName> {
//    property_name: property value
//    <...sub-objects and properties...>
// }
// if IsContainer() is false, this represents a single property value
class WSF_UT_EXPORT UtmlObject
{
public:
   typedef std::map<std::string, UtmlObject> PropertyMap;
 
   UtmlObject()
      : mContainerData(nullptr)
   {
   }
   UtmlObject(const std::string& aValue);
   UtmlObject(const UtmlObject& aRhs);
   UtmlObject& operator=(const UtmlObject& aRhs);

   static UtmlObject makeContainer(const std::string& aType);
   static UtmlObject parse(const std::string& aContainerType, const std::string& aText);

   static UtmlObject parseFile(const std::string& aFilePath);
 
   ~UtmlObject();

   bool IsValue() const { return mContainerData == nullptr; }
   bool IsContainer() const { return mContainerData != nullptr; }

   const std::string& GetValue() const
   {
      assert(!IsContainer());
      return mText;
   }

   void SetValue(const std::string& aValue)
   {
      assert(!IsContainer());
      mText = aValue;
   }

   void SetValueLines(const std::vector<std::string>& aLines);

   std::vector<std::string> GetValueLines() const;
 
   bool GetBoolValue() const;
 
   void SetBoolValue(bool aValue);

 


   const std::string& GetType() const
   {
      assert(IsContainer());
      return mText;
   }

   std::map<std::string, UtmlObject>& GetProperties()
   {
      assert(mContainerData);
      return mContainerData->mProperties;
   }

   const std::map<std::string, UtmlObject>& GetProperties() const
   {
      assert(mContainerData);
      return mContainerData->mProperties;
   }

   UtmlObject* FindProperty(const std::string& aName) const;

   std::string PropertyValue(const std::string& aPropertyName, const std::string& aDefaultValue) const;

   bool Contains(const std::string& aPropertyName) const;

   UtmlObject& operator[](const std::string& aName);

   UtmlObject& operator+=(const UtmlObject& aRhs)
   {
      assert(IsContainer());
      mContainerData->mObjects.push_back(new UtmlObject(aRhs));
      return *this;
   }

   int GetObjectCount() const { return mContainerData ? (int)mContainerData->mObjects.size() : 0; }
#undef GetObject // Avoid conflict with Windows macro
   UtmlObject& GetObject(int aIndex)
   {
      assert(GetObjectCount() > aIndex && aIndex >= 0);
      return *mContainerData->mObjects[aIndex];
   }

   const UtmlObject& GetObject(int aIndex) const
   {
      assert(GetObjectCount() > aIndex && aIndex >= 0);
      return *mContainerData->mObjects[aIndex];
   }

   UtmlObject* FirstObjectByType(const std::string& aTypeName) const;

   void GiveProperty(const std::string& aName, UtmlObject& aObject);
   void GiveObject(UtmlObject& aObject);


   void Swap(UtmlObject& aRhs)
   {
      std::swap(mText, aRhs.mText);
      std::swap(mContainerData, aRhs.mContainerData);
   }
 
   std::string ToText() const;
 
   bool operator==(const UtmlObject& aRhs) const;
 
   bool operator!=(const UtmlObject& aRhs) const { return !this->operator==(aRhs); }
 
private:
   std::vector<UtmlObject*>& GetObjects() { return mContainerData->mObjects; }
 
   struct ContainerData
   {
      ContainerData();
      ~ContainerData();
      ContainerData(const ContainerData& aSrc);
 
      bool operator==(const ContainerData& aRhs) const
      {
         if (this == &aRhs)
         {
            return true;
         }
         if (mObjects.size() != aRhs.mObjects.size())
         {
            return false;
         }
         if (mProperties != aRhs.mProperties)
         {
            return false;
         }
         for (size_t i = 0; i < mObjects.size(); ++i)
         {
            if (*mObjects[i] != *aRhs.mObjects[i])
            {
               return false;
            }
         }
         return true;
      }
 
      bool operator!=(const ContainerData& aRhs) const { return !this->operator==(aRhs); }
 
      std::map<std::string, UtmlObject> mProperties;
      std::vector<UtmlObject*>          mObjects;
 
   private:
      ContainerData& operator=(const ContainerData&); // no imp
   };
   std::string    mText; // value or type
   ContainerData* mContainerData;
};
 

class WSF_UT_EXPORT UtmlParser
{
public:
   UtmlParser(UtTextDocument& aDocument);
   ~UtmlParser();
   bool Parse(UtmlObject& aContainer);
 
private:
   UtmlParser&     operator=(const UtmlParser&); // not implemented
   UtmlParserP*    mImp;
   UtTextDocument* mDocumentPtr;
};

class WSF_UT_EXPORT UtmlWriter
{
public:
   UtmlWriter()
      : mIndent(2)
   {
   }
   void Write(const UtmlObject& aObject, std::ostream& aStream);
   void WriteRoot(const UtmlObject& aObject, std::ostream& aStream);
 
   void WriteFile(const UtmlObject& aObject, const std::string& aFileName, bool aObjectIsImplicitRoot);
   int  mIndent;
 
private:
};
 
#endif