Line data    Source code

       1             : /*
       2             :  * Distributed under the OpenDDS License.
       3             :  * See: http://www.opendds.org/license.html
       4             :  */
       5             : 
       6             : #include "DCPS/DdsDcps_pch.h" //Only the _pch include should start with DCPS/
       7             : 
       8             : #include "ValueWriter.h"
       9             : 
      10             : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
      11             : 
      12             : namespace OpenDDS {
      13             : namespace DCPS {
      14             : 
      15             : #ifdef NONNATIVE_LONGDOUBLE
      16             : void
      17             : ValueWriter::write_float128(long double value)
      18             : {
      19             :   ACE_CDR::LongDouble ld;
      20             :   ACE_CDR_LONG_DOUBLE_ASSIGNMENT(ld, value);
      21             :   write_float128(ld);
      22             : }
      23             : #endif
      24             : 
      25             : void
      26           0 : ValueWriter::write_boolean_array(const ACE_CDR::Boolean* x, size_t length)
      27             : {
      28           0 :   for (size_t i = 0; i != length; ++i) {
      29           0 :     begin_element(i);
      30           0 :     write_boolean(x[i]);
      31           0 :     end_element();
      32             :   }
      33           0 : }
      34             : 
      35             : void
      36           0 : ValueWriter::write_byte_array(const ACE_CDR::Octet* x, size_t length)
      37             : {
      38           0 :   for (size_t i = 0; i != length; ++i) {
      39           0 :     begin_element(i);
      40           0 :     write_byte(x[i]);
      41           0 :     end_element();
      42             :   }
      43           0 : }
      44             : 
      45             : #if OPENDDS_HAS_EXPLICIT_INTS
      46             : void
      47           0 : ValueWriter::write_int8_array(const ACE_CDR::Int8* x, size_t length)
      48             : {
      49           0 :   for (size_t i = 0; i != length; ++i) {
      50           0 :     begin_element(i);
      51           0 :     write_int8(x[i]);
      52           0 :     end_element();
      53             :   }
      54           0 : }
      55             : 
      56             : void
      57           0 : ValueWriter::write_uint8_array(const ACE_CDR::UInt8* x, size_t length)
      58             : {
      59           0 :   for (size_t i = 0; i != length; ++i) {
      60           0 :     begin_element(i);
      61           0 :     write_uint8(x[i]);
      62           0 :     end_element();
      63             :   }
      64           0 : }
      65             : #endif
      66             : 
      67             : void
      68           4 : ValueWriter::write_int16_array(const ACE_CDR::Short* x, size_t length)
      69             : {
      70          12 :   for (size_t i = 0; i != length; ++i) {
      71           8 :     begin_element(i);
      72           8 :     write_int16(x[i]);
      73           8 :     end_element();
      74             :   }
      75           4 : }
      76             : 
      77             : void
      78           0 : ValueWriter::write_uint16_array(const ACE_CDR::UShort* x, size_t length)
      79             : {
      80           0 :   for (size_t i = 0; i != length; ++i) {
      81           0 :     begin_element(i);
      82           0 :     write_uint16(x[i]);
      83           0 :     end_element();
      84             :   }
      85           0 : }
      86             : 
      87             : void
      88           0 : ValueWriter::write_int32_array(const ACE_CDR::Long* x, size_t length)
      89             : {
      90           0 :   for (size_t i = 0; i != length; ++i) {
      91           0 :     begin_element(i);
      92           0 :     write_int32(x[i]);
      93           0 :     end_element();
      94             :   }
      95           0 : }
      96             : 
      97             : void
      98           0 : ValueWriter::write_uint32_array(const ACE_CDR::ULong* x, size_t length)
      99             : {
     100           0 :   for (size_t i = 0; i != length; ++i) {
     101           0 :     begin_element(i);
     102           0 :     write_uint32(x[i]);
     103           0 :     end_element();
     104             :   }
     105           0 : }
     106             : 
     107             : void
     108           0 : ValueWriter::write_int64_array(const ACE_CDR::LongLong* x, size_t length)
     109             : {
     110           0 :   for (size_t i = 0; i != length; ++i) {
     111           0 :     begin_element(i);
     112           0 :     write_int64(x[i]);
     113           0 :     end_element();
     114             :   }
     115           0 : }
     116             : 
     117             : void
     118           0 : ValueWriter::write_uint64_array(const ACE_CDR::ULongLong* x, size_t length)
     119             : {
     120           0 :   for (size_t i = 0; i != length; ++i) {
     121           0 :     begin_element(i);
     122           0 :     write_uint64(x[i]);
     123           0 :     end_element();
     124             :   }
     125           0 : }
     126             : 
     127             : void
     128           0 : ValueWriter::write_float32_array(const ACE_CDR::Float* x, size_t length)
     129             : {
     130           0 :   for (size_t i = 0; i != length; ++i) {
     131           0 :     begin_element(i);
     132           0 :     write_float32(x[i]);
     133           0 :     end_element();
     134             :   }
     135           0 : }
     136             : 
     137             : void
     138           0 : ValueWriter::write_float64_array(const ACE_CDR::Double* x, size_t length)
     139             : {
     140           0 :   for (size_t i = 0; i != length; ++i) {
     141           0 :     begin_element(i);
     142           0 :     write_float64(x[i]);
     143           0 :     end_element();
     144             :   }
     145           0 : }
     146             : 
     147             : void
     148           0 : ValueWriter::write_float128_array(const ACE_CDR::LongDouble* x, size_t length)
     149             : {
     150           0 :   for (size_t i = 0; i != length; ++i) {
     151           0 :     begin_element(i);
     152           0 :     write_float128(x[i]);
     153           0 :     end_element();
     154             :   }
     155           0 : }
     156             : 
     157             : void
     158           0 : ValueWriter::write_char8_array(const ACE_CDR::Char* x, size_t length)
     159             : {
     160           0 :   for (size_t i = 0; i != length; ++i) {
     161           0 :     begin_element(i);
     162           0 :     write_char8(x[i]);
     163           0 :     end_element();
     164             :   }
     165           0 : }
     166             : 
     167             : void
     168           0 : ValueWriter::write_char16_array(const ACE_CDR::WChar* x, size_t length)
     169             : {
     170           0 :   for (size_t i = 0; i != length; ++i) {
     171           0 :     begin_element(i);
     172           0 :     write_char16(x[i]);
     173           0 :     end_element();
     174             :   }
     175           0 : }
     176             : 
     177             : } // namespace DCPS
     178             : } // namespace OpenDDS
     179             : 
     180             : OPENDDS_END_VERSIONED_NAMESPACE_DECL