Line data    Source code

       1             : /*
       2             :  * Distributed under the OpenDDS License.
       3             :  * See: http://www.opendds.org/license.html
       4             :  */
       5             : 
       6             : #ifndef OPENDDS_DCPS_JSON_VALUE_WRITER_H
       7             : #define OPENDDS_DCPS_JSON_VALUE_WRITER_H
       8             : 
       9             : #if defined OPENDDS_RAPIDJSON && !defined OPENDDS_SAFETY_PROFILE
      10             : #  define OPENDDS_HAS_JSON_VALUE_WRITER 1
      11             : #else
      12             : #  define OPENDDS_HAS_JSON_VALUE_WRITER 0
      13             : #endif
      14             : 
      15             : #if OPENDDS_HAS_JSON_VALUE_WRITER
      16             : 
      17             : #include "ValueWriter.h"
      18             : #include "RapidJsonWrapper.h"
      19             : #include "dcps_export.h"
      20             : #include "Definitions.h"
      21             : 
      22             : #include <dds/DdsDcpsCoreTypeSupportImpl.h>
      23             : #include <dds/DdsDcpsTopicC.h>
      24             : 
      25             : #include <iosfwd>
      26             : #include <sstream>
      27             : #include <vector>
      28             : 
      29             : #if !defined (ACE_LACKS_PRAGMA_ONCE)
      30             : #pragma once
      31             : #endif /* ACE_LACKS_PRAGMA_ONCE */
      32             : 
      33             : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
      34             : 
      35             : namespace OpenDDS {
      36             : namespace DCPS {
      37             : 
      38             : /// Convert values to JSON.
      39             : template <typename Writer>
      40             : class JsonValueWriter : public ValueWriter {
      41             : public:
      42          54 :   explicit JsonValueWriter(Writer& writer)
      43          54 :     : writer_(writer)
      44          54 :   {}
      45             : 
      46             :   void begin_struct();
      47             :   void end_struct();
      48             :   void begin_struct_member(const DDS::MemberDescriptor& /*descriptor*/);
      49             :   void end_struct_member();
      50             : 
      51             :   void begin_union();
      52             :   void end_union();
      53             :   void begin_discriminator();
      54             :   void end_discriminator();
      55             :   void begin_union_member(const char* name);
      56             :   void end_union_member();
      57             : 
      58             :   void begin_array();
      59             :   void end_array();
      60             :   void begin_sequence();
      61             :   void end_sequence();
      62             :   void begin_element(size_t idx);
      63             :   void end_element();
      64             : 
      65             :   void write_boolean(ACE_CDR::Boolean value);
      66             :   void write_byte(ACE_CDR::Octet value);
      67             : #if OPENDDS_HAS_EXPLICIT_INTS
      68             :   void write_int8(ACE_CDR::Int8 value);
      69             :   void write_uint8(ACE_CDR::UInt8 value);
      70             : #endif
      71             :   void write_int16(ACE_CDR::Short value);
      72             :   void write_uint16(ACE_CDR::UShort value);
      73             :   void write_int32(ACE_CDR::Long value);
      74             :   void write_uint32(ACE_CDR::ULong value);
      75             :   void write_int64(ACE_CDR::LongLong value);
      76             :   void write_uint64(ACE_CDR::ULongLong value);
      77             :   void write_float32(ACE_CDR::Float value);
      78             :   void write_float64(ACE_CDR::Double value);
      79             :   void write_float128(ACE_CDR::LongDouble value);
      80             :   void write_fixed(const OpenDDS::FaceTypes::Fixed& value);
      81             :   void write_char8(ACE_CDR::Char value);
      82             :   void write_char16(ACE_CDR::WChar value);
      83             :   void write_string(const ACE_CDR::Char* value, size_t length);
      84             :   void write_wstring(const ACE_CDR::WChar* value, size_t length);
      85             :   void write_enum(const char* /*name*/, ACE_CDR::Long value);
      86             : 
      87             : private:
      88             :   Writer& writer_;
      89             : };
      90             : 
      91             : template <typename Writer>
      92           6 : void JsonValueWriter<Writer>::begin_struct()
      93             : {
      94           6 :   writer_.StartObject();
      95           6 : }
      96             : 
      97             : template <typename Writer>
      98           3 : void JsonValueWriter<Writer>::end_struct()
      99             : {
     100           3 :   writer_.EndObject();
     101           3 : }
     102             : 
     103             : template <typename Writer>
     104           5 : void JsonValueWriter<Writer>::begin_struct_member(const DDS::MemberDescriptor& descriptor)
     105             : {
     106           5 :   writer_.Key(descriptor.name());
     107           5 : }
     108             : 
     109             : template <typename Writer>
     110           4 : void JsonValueWriter<Writer>::end_struct_member()
     111           4 : {}
     112             : 
     113             : template <typename Writer>
     114           6 : void JsonValueWriter<Writer>::begin_union()
     115             : {
     116           6 :   writer_.StartObject();
     117           6 : }
     118             : 
     119             : template <typename Writer>
     120           1 : void JsonValueWriter<Writer>::end_union()
     121             : {
     122           1 :   writer_.EndObject();
     123           1 : }
     124             : 
     125             : template <typename Writer>
     126           2 : void JsonValueWriter<Writer>::begin_discriminator()
     127             : {
     128           2 :   writer_.Key("$discriminator");
     129           2 : }
     130             : 
     131             : template <typename Writer>
     132           1 : void JsonValueWriter<Writer>::end_discriminator()
     133           1 : {}
     134             : 
     135             : template <typename Writer>
     136           2 : void JsonValueWriter<Writer>::begin_union_member(const char* name)
     137             : {
     138           2 :   writer_.Key(name);
     139           2 : }
     140             : 
     141             : template <typename Writer>
     142           1 : void JsonValueWriter<Writer>::end_union_member()
     143           1 : {}
     144             : 
     145             : template <typename Writer>
     146           5 : void JsonValueWriter<Writer>::begin_array()
     147             : {
     148           5 :   writer_.StartArray();
     149           5 : }
     150             : 
     151             : template <typename Writer>
     152           4 : void JsonValueWriter<Writer>::end_array()
     153             : {
     154           4 :   writer_.EndArray();
     155           4 : }
     156             : 
     157             : template <typename Writer>
     158           6 : void JsonValueWriter<Writer>::begin_sequence()
     159             : {
     160           6 :   writer_.StartArray();
     161           6 : }
     162             : 
     163             : template <typename Writer>
     164           3 : void JsonValueWriter<Writer>::end_sequence()
     165             : {
     166           3 :   writer_.EndArray();
     167           3 : }
     168             : 
     169             : template <typename Writer>
     170          12 : void JsonValueWriter<Writer>::begin_element(size_t /*idx*/)
     171          12 : {}
     172             : 
     173             : template <typename Writer>
     174          11 : void JsonValueWriter<Writer>::end_element()
     175          11 : {}
     176             : 
     177             : template <typename Writer>
     178           2 : void JsonValueWriter<Writer>::write_boolean(ACE_CDR::Boolean value)
     179             : {
     180           2 :   writer_.Bool(value);
     181           2 : }
     182             : 
     183             : template <typename Writer>
     184           2 : void JsonValueWriter<Writer>::write_byte(ACE_CDR::Octet value)
     185             : {
     186           2 :   writer_.Uint(value);
     187           2 : }
     188             : 
     189             : #if OPENDDS_HAS_EXPLICIT_INTS
     190             : template <typename Writer>
     191           2 : void JsonValueWriter<Writer>::write_int8(ACE_CDR::Int8 value)
     192             : {
     193           2 :   writer_.Int(value);
     194           2 : }
     195             : 
     196             : template <typename Writer>
     197           2 : void JsonValueWriter<Writer>::write_uint8(ACE_CDR::UInt8 value)
     198             : {
     199           2 :   writer_.Uint(value);
     200           2 : }
     201             : #endif
     202             : 
     203             : template <typename Writer>
     204          19 : void JsonValueWriter<Writer>::write_int16(ACE_CDR::Short value)
     205             : {
     206          19 :   writer_.Int(value);
     207          19 : }
     208             : 
     209             : template <typename Writer>
     210           2 : void JsonValueWriter<Writer>::write_uint16(ACE_CDR::UShort value)
     211             : {
     212           2 :   writer_.Uint(value);
     213           2 : }
     214             : 
     215             : template <typename Writer>
     216           2 : void JsonValueWriter<Writer>::write_int32(ACE_CDR::Long value)
     217             : {
     218           2 :   writer_.Int(value);
     219           2 : }
     220             : 
     221             : template <typename Writer>
     222           2 : void JsonValueWriter<Writer>::write_uint32(ACE_CDR::ULong value)
     223             : {
     224           2 :   writer_.Uint(value);
     225           2 : }
     226             : 
     227             : template <typename Writer>
     228           4 : void JsonValueWriter<Writer>::write_int64(ACE_CDR::LongLong value)
     229             : {
     230           4 :   writer_.Int64(value);
     231           4 : }
     232             : 
     233             : template <typename Writer>
     234           2 : void JsonValueWriter<Writer>::write_uint64(ACE_CDR::ULongLong value)
     235             : {
     236           2 :   writer_.Uint64(value);
     237           2 : }
     238             : 
     239             : template <typename Writer>
     240           1 : void JsonValueWriter<Writer>::write_float32(ACE_CDR::Float value)
     241             : {
     242           1 :   writer_.Double(value);
     243           1 : }
     244             : 
     245             : template <typename Writer>
     246           1 : void JsonValueWriter<Writer>::write_float64(ACE_CDR::Double value)
     247             : {
     248           1 :   writer_.Double(value);
     249           1 : }
     250             : 
     251             : template <typename Writer>
     252           1 : void JsonValueWriter<Writer>::write_float128(ACE_CDR::LongDouble value)
     253             : {
     254             :   // TODO
     255           1 :   writer_.Double(value);
     256           1 : }
     257             : 
     258             : template <typename Writer>
     259           1 : void JsonValueWriter<Writer>::write_fixed(const OpenDDS::FaceTypes::Fixed& /*value*/)
     260             : {
     261             :   // TODO
     262           1 :   writer_.String("fixed");
     263           1 : }
     264             : 
     265             : template <typename Writer>
     266           2 : void JsonValueWriter<Writer>::write_char8(ACE_CDR::Char value)
     267             : {
     268           2 :   ACE_CDR::Char s[2] = { value, 0 };
     269           2 :   writer_.String(s, 1);
     270           2 : }
     271             : 
     272             : template <typename Writer>
     273           2 : void JsonValueWriter<Writer>::write_char16(ACE_CDR::WChar value)
     274             : {
     275           2 :   ACE_CDR::WChar s[2] = { value, 0 };
     276             : 
     277           2 :   rapidjson::GenericStringStream<rapidjson::UTF16<> > source(s);
     278           2 :   rapidjson::GenericStringBuffer<rapidjson::UTF8<> > target;
     279             : 
     280           2 :   if (!rapidjson::Transcoder<rapidjson::UTF16<>, rapidjson::UTF8<> >::Transcode(source, target)) {
     281           0 :     return;
     282             :   }
     283             : 
     284           2 :   writer_.String(target.GetString(), static_cast<rapidjson::SizeType>(target.GetLength()));
     285           2 : }
     286             : 
     287             : template <typename Writer>
     288           1 : void JsonValueWriter<Writer>::write_string(const ACE_CDR::Char* value, size_t length)
     289             : {
     290           1 :   writer_.String(value, static_cast<rapidjson::SizeType>(length));
     291           1 : }
     292             : 
     293             : template <typename Writer>
     294           0 : void JsonValueWriter<Writer>::write_wstring(const ACE_CDR::WChar* value, size_t length)
     295             : {
     296           0 :   rapidjson::GenericStringStream<rapidjson::UTF16<> > source(value);
     297           0 :   rapidjson::GenericStringBuffer<rapidjson::UTF8<> > target;
     298             : 
     299           0 :   while (source.Tell() != length) {
     300           0 :     if (!rapidjson::Transcoder<rapidjson::UTF16<>, rapidjson::UTF8<> >::Transcode(source, target)) {
     301           0 :       return;
     302             :     }
     303             :   }
     304             : 
     305           0 :   writer_.String(target.GetString(), static_cast<rapidjson::SizeType>(target.GetLength()));
     306           0 : }
     307             : 
     308             : template <typename Writer>
     309           1 : void JsonValueWriter<Writer>::write_enum(const char* name,
     310             :                                          ACE_CDR::Long /*value*/)
     311             : {
     312           1 :   writer_.String(name);
     313           1 : }
     314             : 
     315             : template<typename T>
     316             : std::string to_json(const T& sample)
     317             : {
     318             :   rapidjson::StringBuffer buffer;
     319             :   rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
     320             :   JsonValueWriter<rapidjson::Writer<rapidjson::StringBuffer> > jvw(writer);
     321             :   vwrite(jvw, sample);
     322             :   writer.Flush();
     323             :   return buffer.GetString();
     324             : }
     325             : 
     326             : template<typename T, typename Writer>
     327             : bool to_json(const T& sample, Writer& writer)
     328             : {
     329             :   JsonValueWriter<Writer> jvw(writer);
     330             :   return vwrite(jvw, sample);
     331             : }
     332             : 
     333             : template<typename T>
     334             : std::string to_json(const DDS::TopicDescription_ptr topic,
     335             :                     const T& sample, const DDS::SampleInfo& sample_info)
     336             : {
     337             :   rapidjson::StringBuffer buffer;
     338             :   rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
     339             :   JsonValueWriter<rapidjson::Writer<rapidjson::StringBuffer> > jvw(writer);
     340             :   jvw.begin_struct();
     341             :   jvw.begin_struct_member(XTypes::MemberDescriptorImpl("topic", false));
     342             :   jvw.begin_struct();
     343             :   jvw.begin_struct_member(XTypes::MemberDescriptorImpl("name", false));
     344             :   CORBA::String_var topic_name = topic->get_name();
     345             :   static_cast<ValueWriter&>(jvw).write_string(topic_name);
     346             :   jvw.end_struct_member();
     347             :   jvw.begin_struct_member(XTypes::MemberDescriptorImpl("type_name", false));
     348             :   CORBA::String_var type_name = topic->get_type_name();
     349             :   static_cast<ValueWriter&>(jvw).write_string(type_name);
     350             :   jvw.end_struct_member();
     351             :   jvw.end_struct();
     352             :   jvw.end_struct_member();
     353             :   jvw.begin_struct_member(XTypes::MemberDescriptorImpl("sample", false));
     354             :   vwrite(jvw, sample);
     355             :   jvw.end_struct_member();
     356             :   jvw.begin_struct_member(XTypes::MemberDescriptorImpl("sample_info", false));
     357             :   vwrite(jvw, sample_info);
     358             :   jvw.end_struct_member();
     359             :   jvw.end_struct();
     360             :   writer.Flush();
     361             :   return buffer.GetString();
     362             : }
     363             : 
     364             : } // namespace DCPS
     365             : } // namespace OpenDDS
     366             : 
     367             : OPENDDS_END_VERSIONED_NAMESPACE_DECL
     368             : 
     369             : #endif
     370             : 
     371             : #endif  /* OPENDDS_DCPS_JSON_VALUE_WRITER_H */