proxyPoseStamped: QuaternionDcps

Go to the documentation of this file.
00001 #include "QuaternionDcps_impl.h"
00002 #include "gapi.h"
00003 #include "gapi_loanRegistry.h"
00004 #include "QuaternionSplDcps.h"
00005 #include "ccpp_DataReader_impl.h"
00006 #include "ccpp_DataReaderView_impl.h"
00007 
00008 
00009 extern c_bool
00010 __Quaternion__copyIn(
00011     c_base base,
00012     struct Quaternion *from,
00013     struct _Quaternion *to);
00014 
00015 extern void
00016 __Quaternion__copyOut(
00017     void *_from,
00018     void *_to);
00019 
00020 // DDS Quaternion TypeSupportFactory Object Body
00021 
00022 ::DDS::DataWriter_ptr
00023 QuaternionTypeSupportFactory::create_datawriter (gapi_dataWriter handle)
00024 {
00025     return new QuaternionDataWriter_impl(handle);
00026 }
00027 
00028 ::DDS::DataReader_ptr
00029 QuaternionTypeSupportFactory::create_datareader (gapi_dataReader handle)
00030 {
00031     return new QuaternionDataReader_impl (handle);
00032 }
00033 
00034 
00035 ::DDS::DataReaderView_ptr
00036 QuaternionTypeSupportFactory::create_view (gapi_dataReaderView handle)
00037 {
00038     return new QuaternionDataReaderView_impl (handle);
00039 }
00040 
00041 // DDS Quaternion TypeSupport Object Body
00042 
00043 QuaternionTypeSupport::QuaternionTypeSupport(void) :
00044     TypeSupport_impl(
00045         __Quaternion__name(),
00046         __Quaternion__keys(),
00047         QuaternionTypeSupport::metaDescriptor,
00048         (gapi_copyIn) __Quaternion__copyIn,
00049         (gapi_copyOut) __Quaternion__copyOut,
00050         (gapi_readerCopy) ::DDS::ccpp_DataReaderCopy<QuaternionSeq, Quaternion>,
00051         new  QuaternionTypeSupportFactory())
00052 {
00053     // Parent constructor takes care of everything.
00054 }
00055 
00056 QuaternionTypeSupport::~QuaternionTypeSupport(void)
00057 {
00058     // Parent destructor takes care of everything.
00059 }
00060 
00061 ::DDS::ReturnCode_t
00062 QuaternionTypeSupport::register_type(
00063     ::DDS::DomainParticipant_ptr domain,
00064     const char * type_name) THROW_ORB_EXCEPTIONS
00065 {
00066     return TypeSupport_impl::register_type(domain, type_name);
00067 }
00068 
00069 char *
00070 QuaternionTypeSupport::get_type_name() THROW_ORB_EXCEPTIONS
00071 {
00072     return TypeSupport_impl::get_type_name();
00073 }
00074 
00075 // DDS Quaternion DataWriter_impl Object Body
00076 
00077 QuaternionDataWriter_impl::QuaternionDataWriter_impl (
00078     gapi_dataWriter handle
00079 ) : ::DDS::DataWriter_impl(handle)
00080 {
00081     // Parent constructor takes care of everything.
00082 }
00083 
00084 QuaternionDataWriter_impl::~QuaternionDataWriter_impl(void)
00085 {
00086     // Parent destructor takes care of everything.
00087 }
00088 
00089 ::DDS::InstanceHandle_t
00090 QuaternionDataWriter_impl::register_instance(
00091     const Quaternion & instance_data) THROW_ORB_EXCEPTIONS
00092 {
00093     return DataWriter_impl::register_instance(&instance_data);
00094 }
00095 
00096 ::DDS::InstanceHandle_t
00097 QuaternionDataWriter_impl::register_instance_w_timestamp(
00098     const Quaternion & instance_data,
00099     const ::DDS::Time_t & source_timestamp) THROW_ORB_EXCEPTIONS
00100 {
00101     return DataWriter_impl::register_instance_w_timestamp(&instance_data, source_timestamp);
00102 }
00103 
00104 ::DDS::ReturnCode_t
00105 QuaternionDataWriter_impl::unregister_instance(
00106     const Quaternion & instance_data,
00107     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00108 {
00109     return DataWriter_impl::unregister_instance(&instance_data, handle);
00110 }
00111 
00112 ::DDS::ReturnCode_t
00113 QuaternionDataWriter_impl::unregister_instance_w_timestamp(
00114     const Quaternion & instance_data,
00115     ::DDS::InstanceHandle_t handle,
00116     const ::DDS::Time_t & source_timestamp) THROW_ORB_EXCEPTIONS
00117 {
00118     return DataWriter_impl::unregister_instance_w_timestamp(&instance_data, handle, source_timestamp);
00119 }
00120 
00121 ::DDS::ReturnCode_t
00122 QuaternionDataWriter_impl::write(
00123     const Quaternion & instance_data,
00124     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00125 {
00126     return DataWriter_impl::write(&instance_data, handle);
00127 }
00128 
00129 ::DDS::ReturnCode_t
00130 QuaternionDataWriter_impl::write_w_timestamp(
00131     const Quaternion & instance_data,
00132     ::DDS::InstanceHandle_t handle,
00133     const ::DDS::Time_t & source_timestamp) THROW_ORB_EXCEPTIONS
00134 {
00135     return DataWriter_impl::write_w_timestamp(&instance_data, handle, source_timestamp);
00136 }
00137 
00138 ::DDS::ReturnCode_t
00139 QuaternionDataWriter_impl::dispose(
00140     const Quaternion & instance_data,
00141     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00142 {
00143     return DataWriter_impl::dispose(&instance_data, handle);
00144 }
00145 
00146 ::DDS::ReturnCode_t
00147 QuaternionDataWriter_impl::dispose_w_timestamp(
00148     const Quaternion & instance_data,
00149     ::DDS::InstanceHandle_t handle,
00150     const ::DDS::Time_t & source_timestamp) THROW_ORB_EXCEPTIONS
00151 {
00152     return DataWriter_impl::dispose_w_timestamp(&instance_data, handle, source_timestamp);
00153 }
00154 
00155 ::DDS::ReturnCode_t
00156 QuaternionDataWriter_impl::writedispose(
00157     const Quaternion & instance_data,
00158     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00159 {
00160     return DataWriter_impl::writedispose(&instance_data, handle);
00161 }
00162 
00163 ::DDS::ReturnCode_t
00164 QuaternionDataWriter_impl::writedispose_w_timestamp(
00165     const Quaternion & instance_data,
00166     ::DDS::InstanceHandle_t handle,
00167     const ::DDS::Time_t & source_timestamp) THROW_ORB_EXCEPTIONS
00168 {
00169     return DataWriter_impl::writedispose_w_timestamp(&instance_data, handle, source_timestamp);
00170 }
00171 
00172 ::DDS::ReturnCode_t
00173 QuaternionDataWriter_impl::get_key_value(
00174     Quaternion & key_holder,
00175     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00176 {
00177     return DataWriter_impl::get_key_value(&key_holder, handle);
00178 }
00179 
00180 ::DDS::InstanceHandle_t
00181 QuaternionDataWriter_impl::lookup_instance(
00182     const Quaternion & instance_data) THROW_ORB_EXCEPTIONS
00183 {
00184     return DataWriter_impl::lookup_instance(&instance_data);
00185 }
00186 
00187 // DDS Quaternion DataReader_impl Object Body
00188 
00189 QuaternionDataReader_impl::QuaternionDataReader_impl (
00190     gapi_dataReader handle
00191 ) : ::DDS::DataReader_impl(handle)
00192 {
00193     // Parent constructor takes care of everything.
00194 }
00195 
00196 QuaternionDataReader_impl::~QuaternionDataReader_impl(void)
00197 {
00198     // Parent destructor takes care of everything.
00199 }
00200 
00201 
00202 ::DDS::ReturnCode_t
00203 QuaternionDataReader_impl::read(
00204     QuaternionSeq & received_data,
00205     ::DDS::SampleInfoSeq & info_seq,
00206     CORBA::Long max_samples,
00207     ::DDS::SampleStateMask sample_states,
00208     ::DDS::ViewStateMask view_states,
00209     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00210 {
00211     ::DDS::ReturnCode_t status;
00212 
00213     status = check_preconditions(received_data, info_seq, max_samples);
00214     if ( status == ::DDS::RETCODE_OK ) {
00215         status = DataReader_impl::read(&received_data, info_seq, max_samples, sample_states, view_states, instance_states);
00216     }
00217     return status;
00218 }
00219 
00220 ::DDS::ReturnCode_t
00221 QuaternionDataReader_impl::take(
00222     QuaternionSeq & received_data,
00223     ::DDS::SampleInfoSeq & info_seq,
00224     CORBA::Long max_samples,
00225     ::DDS::SampleStateMask sample_states,
00226     ::DDS::ViewStateMask view_states,
00227     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00228 {
00229     ::DDS::ReturnCode_t status;
00230 
00231     status = check_preconditions(received_data, info_seq, max_samples);
00232     if ( status == ::DDS::RETCODE_OK ) {
00233         status = DataReader_impl::take(&received_data, info_seq, max_samples, sample_states, view_states, instance_states);
00234     }
00235     return status;
00236 }
00237 
00238 ::DDS::ReturnCode_t
00239 QuaternionDataReader_impl::read_w_condition(
00240     QuaternionSeq & received_data,
00241     ::DDS::SampleInfoSeq & info_seq,
00242     CORBA::Long max_samples,
00243     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00244 {
00245     ::DDS::ReturnCode_t status;
00246 
00247     status = check_preconditions(received_data, info_seq, max_samples);
00248     if ( status == ::DDS::RETCODE_OK ) {
00249         status = DataReader_impl::read_w_condition(&received_data, info_seq, max_samples, a_condition);
00250     }
00251     return status;
00252 }
00253 
00254 ::DDS::ReturnCode_t
00255 QuaternionDataReader_impl::take_w_condition(
00256     QuaternionSeq & received_data,
00257     ::DDS::SampleInfoSeq & info_seq,
00258     CORBA::Long max_samples,
00259     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00260 {
00261     ::DDS::ReturnCode_t status;
00262 
00263     status = check_preconditions(received_data, info_seq, max_samples);
00264     if ( status == ::DDS::RETCODE_OK ) {
00265         status = DataReader_impl::take_w_condition(&received_data, info_seq, max_samples, a_condition);
00266     }
00267     return status;
00268 }
00269 
00270 
00271 ::DDS::ReturnCode_t
00272 QuaternionDataReader_impl::read_next_sample(
00273     Quaternion & received_data,
00274     ::DDS::SampleInfo & sample_info) THROW_ORB_EXCEPTIONS
00275 {
00276     return DataReader_impl::read_next_sample(&received_data, sample_info);
00277 }
00278 
00279 
00280 ::DDS::ReturnCode_t
00281 QuaternionDataReader_impl::take_next_sample(
00282     Quaternion & received_data,
00283     ::DDS::SampleInfo & sample_info) THROW_ORB_EXCEPTIONS
00284 {
00285     return DataReader_impl::take_next_sample(&received_data, sample_info);
00286 }
00287 
00288 
00289 ::DDS::ReturnCode_t
00290 QuaternionDataReader_impl::read_instance(
00291     QuaternionSeq & received_data,
00292     ::DDS::SampleInfoSeq & info_seq,
00293     CORBA::Long max_samples,
00294     ::DDS::InstanceHandle_t a_handle,
00295     ::DDS::SampleStateMask sample_states,
00296     ::DDS::ViewStateMask view_states,
00297     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00298 {
00299     ::DDS::ReturnCode_t status;
00300 
00301     status = check_preconditions(received_data, info_seq, max_samples);
00302     if ( status == ::DDS::RETCODE_OK ) {
00303         status = DataReader_impl::read_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00304     }
00305     return status;
00306 }
00307 
00308 ::DDS::ReturnCode_t
00309 QuaternionDataReader_impl::take_instance(
00310     QuaternionSeq & received_data,
00311     ::DDS::SampleInfoSeq & info_seq,
00312     CORBA::Long max_samples,
00313     ::DDS::InstanceHandle_t a_handle,
00314     ::DDS::SampleStateMask sample_states,
00315     ::DDS::ViewStateMask view_states,
00316     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00317 {
00318     ::DDS::ReturnCode_t status;
00319 
00320     status = check_preconditions(received_data, info_seq, max_samples);
00321     if ( status == ::DDS::RETCODE_OK ) {
00322         status = DataReader_impl::take_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00323     }
00324     return status;
00325 }
00326 
00327 ::DDS::ReturnCode_t
00328 QuaternionDataReader_impl::read_next_instance(
00329     QuaternionSeq & received_data,
00330     ::DDS::SampleInfoSeq & info_seq,
00331     CORBA::Long max_samples,
00332     ::DDS::InstanceHandle_t a_handle,
00333     ::DDS::SampleStateMask sample_states,
00334     ::DDS::ViewStateMask view_states,
00335     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00336 {
00337     ::DDS::ReturnCode_t status;
00338 
00339     status = check_preconditions(received_data, info_seq, max_samples);
00340     if ( status == ::DDS::RETCODE_OK ) {
00341         status = DataReader_impl::read_next_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00342     }
00343     return status;
00344 }
00345 
00346 ::DDS::ReturnCode_t
00347 QuaternionDataReader_impl::take_next_instance(
00348     QuaternionSeq & received_data,
00349     ::DDS::SampleInfoSeq & info_seq,
00350     CORBA::Long max_samples,
00351     ::DDS::InstanceHandle_t a_handle,
00352     ::DDS::SampleStateMask sample_states,
00353     ::DDS::ViewStateMask view_states,
00354     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00355 {
00356     ::DDS::ReturnCode_t status;
00357 
00358     status = check_preconditions(received_data, info_seq, max_samples);
00359     if ( status == ::DDS::RETCODE_OK ) {
00360         status = DataReader_impl::take_next_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00361     }
00362     return status;
00363 }
00364 
00365 
00366 ::DDS::ReturnCode_t
00367 QuaternionDataReader_impl::read_next_instance_w_condition(
00368     QuaternionSeq & received_data,
00369     ::DDS::SampleInfoSeq & info_seq,
00370     CORBA::Long max_samples,
00371     ::DDS::InstanceHandle_t a_handle,
00372     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00373 {
00374     ::DDS::ReturnCode_t status;
00375 
00376     status = check_preconditions(received_data, info_seq, max_samples);
00377     if ( status == ::DDS::RETCODE_OK ) {
00378         status = DataReader_impl::read_next_instance_w_condition(&received_data, info_seq, max_samples, a_handle, a_condition);
00379     }
00380     return status;
00381 }
00382 
00383 
00384 ::DDS::ReturnCode_t
00385 QuaternionDataReader_impl::take_next_instance_w_condition(
00386     QuaternionSeq & received_data,
00387     ::DDS::SampleInfoSeq & info_seq,
00388     CORBA::Long max_samples,
00389     ::DDS::InstanceHandle_t a_handle,
00390     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00391 {
00392     ::DDS::ReturnCode_t status;
00393 
00394     status = check_preconditions(received_data, info_seq, max_samples);
00395     if ( status == ::DDS::RETCODE_OK ) {
00396         status = DataReader_impl::take_next_instance_w_condition(&received_data, info_seq, max_samples, a_handle, a_condition);
00397     }
00398     return status;
00399 }
00400 
00401 
00402 ::DDS::ReturnCode_t
00403 QuaternionDataReader_impl::return_loan(
00404     QuaternionSeq & received_data,
00405     ::DDS::SampleInfoSeq & info_seq) THROW_ORB_EXCEPTIONS
00406 {
00407     ::DDS::ReturnCode_t status = ::DDS::RETCODE_OK;
00408 
00409     if ( received_data.length() > 0 ) {
00410         if (received_data.length() == info_seq.length() &&
00411             received_data.release() == info_seq.release() ) {
00412             if (!received_data.release()) {
00413                 status = DataReader_impl::return_loan( received_data.get_buffer(),
00414                                                        info_seq.get_buffer() );
00415 
00416                 if ( status == ::DDS::RETCODE_OK ) {
00417                     if ( !received_data.release() ) {
00418                         QuaternionSeq::freebuf( received_data.get_buffer(false) );
00419                         received_data.replace(0, 0, NULL, false);
00420                         ::DDS::SampleInfoSeq::freebuf( info_seq.get_buffer(false) );
00421                         info_seq.replace(0, 0, NULL, false);
00422                     }
00423                 } else if ( status == ::DDS::RETCODE_NO_DATA ) {
00424                     if ( received_data.release() ) {
00425                         status = ::DDS::RETCODE_OK;
00426                     } else {
00427                         status = ::DDS::RETCODE_PRECONDITION_NOT_MET;
00428                     }
00429                 }
00430             }
00431         } else {
00432             status = ::DDS::RETCODE_PRECONDITION_NOT_MET;
00433         }
00434     }
00435     return status;
00436 }
00437 
00438 
00439 ::DDS::ReturnCode_t
00440 QuaternionDataReader_impl::get_key_value(
00441     Quaternion & key_holder,
00442     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00443 {
00444     return DataReader_impl::get_key_value(&key_holder, handle);
00445 }
00446 
00447 ::DDS::InstanceHandle_t
00448 QuaternionDataReader_impl::lookup_instance(
00449     const Quaternion & instance) THROW_ORB_EXCEPTIONS
00450 {
00451     return DataReader_impl::lookup_instance(&instance);
00452 }
00453 
00454 ::DDS::ReturnCode_t
00455 QuaternionDataReader_impl::check_preconditions(
00456     QuaternionSeq & received_data,
00457     ::DDS::SampleInfoSeq & info_seq,
00458     CORBA::Long max_samples)
00459 {
00460     ::DDS::ReturnCode_t status = ::DDS::RETCODE_PRECONDITION_NOT_MET;
00461 
00462     if ( received_data.length() == info_seq.length() &&
00463          received_data.maximum() == info_seq.maximum() &&
00464          received_data.release() == info_seq.release() ) {
00465         if ( received_data.maximum() == 0 || received_data.release() ) {
00466             if (received_data.maximum() == 0 ||
00467                 max_samples <= static_cast<CORBA::Long>(received_data.maximum()) ||
00468                 max_samples == ::DDS::LENGTH_UNLIMITED ) {
00469                 status = ::DDS::RETCODE_OK;
00470             }
00471         }
00472     }
00473     return status;
00474 }
00475 
00476 
00477 // DDS Quaternion DataReaderView_impl Object Body
00478 
00479 QuaternionDataReaderView_impl::QuaternionDataReaderView_impl (
00480     gapi_dataReaderView handle
00481 ) : ::DDS::DataReaderView_impl(handle)
00482 {
00483     // Parent constructor takes care of everything.
00484 }
00485 
00486 QuaternionDataReaderView_impl::~QuaternionDataReaderView_impl(void)
00487 {
00488     // Parent destructor takes care of everything.
00489 }
00490 
00491 
00492 ::DDS::ReturnCode_t
00493 QuaternionDataReaderView_impl::read(
00494     QuaternionSeq & received_data,
00495     ::DDS::SampleInfoSeq & info_seq,
00496     CORBA::Long max_samples,
00497     ::DDS::SampleStateMask sample_states,
00498     ::DDS::ViewStateMask view_states,
00499     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00500 {
00501     ::DDS::ReturnCode_t status;
00502 
00503     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00504     if ( status == ::DDS::RETCODE_OK ) {
00505         status = DataReaderView_impl::read(&received_data, info_seq, max_samples, sample_states, view_states, instance_states);
00506     }
00507     return status;
00508 }
00509 
00510 ::DDS::ReturnCode_t
00511 QuaternionDataReaderView_impl::take(
00512     QuaternionSeq & received_data,
00513     ::DDS::SampleInfoSeq & info_seq,
00514     CORBA::Long max_samples,
00515     ::DDS::SampleStateMask sample_states,
00516     ::DDS::ViewStateMask view_states,
00517     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00518 {
00519     ::DDS::ReturnCode_t status;
00520 
00521     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00522     if ( status == ::DDS::RETCODE_OK ) {
00523         status = DataReaderView_impl::take(&received_data, info_seq, max_samples, sample_states, view_states, instance_states);
00524     }
00525     return status;
00526 }
00527 
00528 ::DDS::ReturnCode_t
00529 QuaternionDataReaderView_impl::read_w_condition(
00530     QuaternionSeq & received_data,
00531     ::DDS::SampleInfoSeq & info_seq,
00532     CORBA::Long max_samples,
00533     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00534 {
00535     ::DDS::ReturnCode_t status;
00536 
00537     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00538     if ( status == ::DDS::RETCODE_OK ) {
00539         status = DataReaderView_impl::read_w_condition(&received_data, info_seq, max_samples, a_condition);
00540     }
00541     return status;
00542 }
00543 
00544 ::DDS::ReturnCode_t
00545 QuaternionDataReaderView_impl::take_w_condition(
00546     QuaternionSeq & received_data,
00547     ::DDS::SampleInfoSeq & info_seq,
00548     CORBA::Long max_samples,
00549     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00550 {
00551     ::DDS::ReturnCode_t status;
00552 
00553     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00554     if ( status == ::DDS::RETCODE_OK ) {
00555         status = DataReaderView_impl::take_w_condition(&received_data, info_seq, max_samples, a_condition);
00556     }
00557     return status;
00558 }
00559 
00560 
00561 ::DDS::ReturnCode_t
00562 QuaternionDataReaderView_impl::read_next_sample(
00563     Quaternion & received_data,
00564     ::DDS::SampleInfo & sample_info) THROW_ORB_EXCEPTIONS
00565 {
00566     return DataReaderView_impl::read_next_sample(&received_data, sample_info);
00567 }
00568 
00569 
00570 ::DDS::ReturnCode_t
00571 QuaternionDataReaderView_impl::take_next_sample(
00572     Quaternion & received_data,
00573     ::DDS::SampleInfo & sample_info) THROW_ORB_EXCEPTIONS
00574 {
00575     return DataReaderView_impl::take_next_sample(&received_data, sample_info);
00576 }
00577 
00578 
00579 ::DDS::ReturnCode_t
00580 QuaternionDataReaderView_impl::read_instance(
00581     QuaternionSeq & received_data,
00582     ::DDS::SampleInfoSeq & info_seq,
00583     CORBA::Long max_samples,
00584     ::DDS::InstanceHandle_t a_handle,
00585     ::DDS::SampleStateMask sample_states,
00586     ::DDS::ViewStateMask view_states,
00587     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00588 {
00589     ::DDS::ReturnCode_t status;
00590 
00591     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00592     if ( status == ::DDS::RETCODE_OK ) {
00593         status = DataReaderView_impl::read_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00594     }
00595     return status;
00596 }
00597 
00598 ::DDS::ReturnCode_t
00599 QuaternionDataReaderView_impl::take_instance(
00600     QuaternionSeq & received_data,
00601     ::DDS::SampleInfoSeq & info_seq,
00602     CORBA::Long max_samples,
00603     ::DDS::InstanceHandle_t a_handle,
00604     ::DDS::SampleStateMask sample_states,
00605     ::DDS::ViewStateMask view_states,
00606     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00607 {
00608     ::DDS::ReturnCode_t status;
00609 
00610     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00611     if ( status == ::DDS::RETCODE_OK ) {
00612         status = DataReaderView_impl::take_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00613     }
00614     return status;
00615 }
00616 
00617 ::DDS::ReturnCode_t
00618 QuaternionDataReaderView_impl::read_next_instance(
00619     QuaternionSeq & received_data,
00620     ::DDS::SampleInfoSeq & info_seq,
00621     CORBA::Long max_samples,
00622     ::DDS::InstanceHandle_t a_handle,
00623     ::DDS::SampleStateMask sample_states,
00624     ::DDS::ViewStateMask view_states,
00625     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00626 {
00627     ::DDS::ReturnCode_t status;
00628 
00629     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00630     if ( status == ::DDS::RETCODE_OK ) {
00631         status = DataReaderView_impl::read_next_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00632     }
00633     return status;
00634 }
00635 
00636 ::DDS::ReturnCode_t
00637 QuaternionDataReaderView_impl::take_next_instance(
00638     QuaternionSeq & received_data,
00639     ::DDS::SampleInfoSeq & info_seq,
00640     CORBA::Long max_samples,
00641     ::DDS::InstanceHandle_t a_handle,
00642     ::DDS::SampleStateMask sample_states,
00643     ::DDS::ViewStateMask view_states,
00644     ::DDS::InstanceStateMask instance_states) THROW_ORB_EXCEPTIONS
00645 {
00646     ::DDS::ReturnCode_t status;
00647 
00648     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00649     if ( status == ::DDS::RETCODE_OK ) {
00650         status = DataReaderView_impl::take_next_instance(&received_data, info_seq, max_samples, a_handle, sample_states, view_states, instance_states);
00651     }
00652     return status;
00653 }
00654 
00655 
00656 ::DDS::ReturnCode_t
00657 QuaternionDataReaderView_impl::read_next_instance_w_condition(
00658     QuaternionSeq & received_data,
00659     ::DDS::SampleInfoSeq & info_seq,
00660     CORBA::Long max_samples,
00661     ::DDS::InstanceHandle_t a_handle,
00662     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00663 {
00664     ::DDS::ReturnCode_t status;
00665 
00666     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00667     if ( status == ::DDS::RETCODE_OK ) {
00668         status = DataReaderView_impl::read_next_instance_w_condition(&received_data, info_seq, max_samples, a_handle, a_condition);
00669     }
00670     return status;
00671 }
00672 
00673 
00674 ::DDS::ReturnCode_t
00675 QuaternionDataReaderView_impl::take_next_instance_w_condition(
00676     QuaternionSeq & received_data,
00677     ::DDS::SampleInfoSeq & info_seq,
00678     CORBA::Long max_samples,
00679     ::DDS::InstanceHandle_t a_handle,
00680     ::DDS::ReadCondition_ptr a_condition) THROW_ORB_EXCEPTIONS
00681 {
00682     ::DDS::ReturnCode_t status;
00683 
00684     status = QuaternionDataReader_impl::check_preconditions(received_data, info_seq, max_samples);
00685     if ( status == ::DDS::RETCODE_OK ) {
00686         status = DataReaderView_impl::take_next_instance_w_condition(&received_data, info_seq, max_samples, a_handle, a_condition);
00687     }
00688     return status;
00689 }
00690 
00691 
00692 ::DDS::ReturnCode_t
00693 QuaternionDataReaderView_impl::return_loan(
00694     QuaternionSeq & received_data,
00695     ::DDS::SampleInfoSeq & info_seq) THROW_ORB_EXCEPTIONS
00696 {
00697     ::DDS::ReturnCode_t status = ::DDS::RETCODE_OK;
00698 
00699     if ( received_data.length() > 0 ) {
00700         if (received_data.length() == info_seq.length() &&
00701             received_data.release() == info_seq.release() ) {
00702             if (!received_data.release()) {
00703                 status = DataReaderView_impl::return_loan( received_data.get_buffer(),
00704                                                        info_seq.get_buffer() );
00705 
00706                 if ( status == ::DDS::RETCODE_OK ) {
00707                     if ( !received_data.release() ) {
00708                         QuaternionSeq::freebuf( received_data.get_buffer(false) );
00709                         received_data.replace(0, 0, NULL, false);
00710                         ::DDS::SampleInfoSeq::freebuf( info_seq.get_buffer(false) );
00711                         info_seq.replace(0, 0, NULL, false);
00712                     }
00713                 } else if ( status == ::DDS::RETCODE_NO_DATA ) {
00714                     if ( received_data.release() ) {
00715                         status = ::DDS::RETCODE_OK;
00716                     } else {
00717                         status = ::DDS::RETCODE_PRECONDITION_NOT_MET;
00718                     }
00719                 }
00720             }
00721         } else {
00722             status = ::DDS::RETCODE_PRECONDITION_NOT_MET;
00723         }
00724     }
00725     return status;
00726 }
00727 
00728 
00729 ::DDS::ReturnCode_t
00730 QuaternionDataReaderView_impl::get_key_value(
00731     Quaternion & key_holder,
00732     ::DDS::InstanceHandle_t handle) THROW_ORB_EXCEPTIONS
00733 {
00734     return DataReaderView_impl::get_key_value(&key_holder, handle);
00735 }
00736 
00737 ::DDS::InstanceHandle_t
00738 QuaternionDataReaderView_impl::lookup_instance(
00739     const Quaternion & instance) THROW_ORB_EXCEPTIONS
00740 {
00741     return DataReaderView_impl::lookup_instance(&instance);
00742 }
00743 
00744 
00745 
00746 const char * QuaternionTypeSupport::metaDescriptor = "<MetaData version=\"1.0.0\"><Struct name=\"Quaternion\"><Member name=\"x\"><Double/></Member><Member name=\"y\">"
00747 "<Double/></Member><Member name=\"z\"><Double/></Member><Member name=\"w\"><Double/></Member></Struct>"
00748 "</MetaData>";