TAO/tao/Vector_CDR_T.h

   1 #ifndef guard_vector_cdr
   2 #define guard_vector_cdr
   3 /**
   4  * @file
   5  *
   6  * @brief CDR (de)marshaling for std::vector
   7  *
   8  * @author Jeff Parsons
   9  */
  10
  11 #include <vector>
  12
  13 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  14
  15 namespace TAO
  16 {
  17   template<typename T>
  18   bool
  19   marshal_value_vector (
  20     TAO_OutputCDR &strm,
  21     const std::vector<T> &source)
  22   {
  23     ::CORBA::ULong const length = source.size ();
  24
  25     if (! (strm << length))
  26       {
  27         return false;
  28       }
  29
  30     for (typename std::vector<T>::const_iterator iter =
  31            source.begin ();
  32          iter != source.end ();
  33          ++iter)
  34       {
  35         if (! (strm << *iter))
  36           {
  37             return false;
  38           }
  39       }
  40
  41     return true;
  42   }
  43
  44   template<typename T>
  45   bool
  46   demarshal_value_vector (
  47     TAO_InputCDR &strm,
  48     std::vector<T> &target)
  49   {
  50     ::CORBA::ULong new_length = 0;
  51
  52     if (! (strm >> new_length))
  53       {
  54         return false;
  55       }
  56
  57     if (new_length > strm.length ())
  58       {
  59         return false;
  60       }
  61
  62     std::vector<T> tmp;
  63     tmp.reserve (new_length);
  64     T tmp_elem;
  65
  66     for ( ::CORBA::ULong i = 0; i < new_length; ++i)
  67       {
  68         if (! (strm >> tmp_elem))
  69           {
  70             return false;
  71           }
  72
  73         tmp[i] = tmp_elem;
  74       }
  75
  76     tmp.swap(target);
  77     return true;
  78   }
  79
  80   template<typename T>
  81   bool
  82   marshal_objref_vector (
  83     TAO_OutputCDR &strm,
  84     const std::vector<typename T::_ptr_type> &source)
  85   {
  86     ::CORBA::ULong const length = source.size ();
  87
  88     if (! (strm << length))
  89       {
  90         return false;
  91       }
  92
  93     for (typename std::vector<typename T::_ptr_type>::const_iterator i =
  94            source.begin ();
  95          i != source.end ();
  96          ++i)
  97       {
  98         if (! (TAO::Objref_Traits<T>::marshal (*i, strm)))
  99           {
 100             return false;
 101           }
 102       }
 103
 104     return true;
 105   }
 106
 107   template<typename T>
 108   bool
 109   demarshal_objref_vector (
 110     TAO_InputCDR &strm,
 111     std::vector<typename T::_ptr_type> &target)
 112   {
 113     ::CORBA::ULong new_length = 0;
 114
 115     if (! (strm >> new_length))
 116       {
 117         return false;
 118       }
 119
 120     if (new_length > strm.length ())
 121       {
 122         return false;
 123       }
 124
 125     std::vector<typename T::_ptr_type> tmp;
 126     tmp.reserve (new_length);
 127     typename T::_ptr_type tmp_elem = T::_nil ();
 128
 129     for ( ::CORBA::ULong i = 0; i < new_length; ++i)
 130       {
 131         if (! (strm >> tmp_elem))
 132           {
 133             return false;
 134           }
 135
 136         tmp[i] = tmp_elem;
 137       }
 138
 139     tmp.swap (target);
 140     return true;
 141   }
 142
 143   template<typename T_forany>
 144   bool
 145   marshal_array_vector (
 146     TAO_OutputCDR &strm,
 147     const std::vector<typename T_forany::_slice_type *> &source)
 148   {
 149     typedef TAO_FixedArray_Var_T <typename T_forany::_array_type,
 150                                   typename T_forany::_slice_type,
 151                                   typename T_forany::_tag_type> var_type;
 152     ::CORBA::ULong const length = source.size ();
 153
 154     if (! (strm << length))
 155       {
 156         return false;
 157       }
 158
 159     for (std::vector<typename T_forany::_slice_type *> i =
 160            source.begin ();
 161          i != source.end ();
 162          ++i)
 163       {
 164         var_type tmp_array =
 165           TAO::Array_Traits<T_forany>::dup (*i);
 166         T_forany const tmp (tmp_array.inout ());
 167
 168         if (! (strm << tmp))
 169           {
 170             return false;
 171           }
 172       }
 173
 174     return true;
 175   }
 176
 177   template<typename T_forany>
 178   bool
 179   demarshal_array_vector (
 180     TAO_InputCDR &strm,
 181     const std::vector<typename T_forany::_slice_type *> &source)
 182   {
 183     typedef TAO::Array_Traits<T_forany> array_traits;
 184     ::CORBA::ULong new_length = 0;
 185
 186     if (! (strm >> new_length))
 187       {
 188         return false;
 189       }
 190
 191     if (new_length > strm.length ())
 192       {
 193         return false;
 194       }
 195
 196     std::vector<typename T_forany::_slice_type *> tmp_vec;
 197     tmp_vec.reserve (new_length);
 198
 199     for ( ::CORBA::ULong i = 0; i < new_length; ++i)
 200       {
 201         T_forany tmp_array (array_traits::alloc ());
 202         bool const _tao_marshal_flag = (strm >> tmp_array);
 203
 204         if (_tao_marshal_flag)
 205           {
 206             array_traits::copy (tmp_vec[i], tmp_array.in ());
 207           }
 208
 209         array_traits::free (tmp_array.inout ());
 210
 211         if (!_tao_marshal_flag)
 212           {
 213             return false;
 214           }
 215       }
 216
 217     tmp_vec.swap (source);
 218     return true;
 219   }
 220 }
 221
 222 TAO_END_VERSIONED_NAMESPACE_DECL
 223
 224 #endif // guard_vector_cdr