dbus-cxx logo

messageappenditerator.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  *   Copyright (C) 2009 by Rick L. Vinyard, Jr.                            *
00003  *   rvinyard@cs.nmsu.edu                                                  *
00004  *                                                                         *
00005  *   This file is part of the dbus-cxx library.                            *
00006  *                                                                         *
00007  *   The dbus-cxx library is free software; you can redistribute it and/or *
00008  *   modify it under the terms of the GNU General Public License           *
00009  *   version 3 as published by the Free Software Foundation.               *
00010  *                                                                         *
00011  *   The dbus-cxx library is distributed in the hope that it will be       *
00012  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
00013  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
00014  *   General Public License for more details.                              *
00015  *                                                                         *
00016  *   You should have received a copy of the GNU General Public License     *
00017  *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
00018  ***************************************************************************/
00019 #ifndef DBUSMESSAGEAPPENDITERATOR_H
00020 #define DBUSMESSAGEAPPENDITERATOR_H
00021 
00022 #include <string>
00023 #include <vector>
00024 
00025 #include <dbus/dbus.h>
00026 
00027 #include <dbus-cxx/utility.h>
00028 #include <dbus-cxx/error.h>
00029 #include <dbus-cxx/pointer.h>
00030 
00031 namespace DBus
00032 {
00033 
00034   class Message;
00035 
00043   class MessageAppendIterator
00044   {
00045     public:
00046 
00047       MessageAppendIterator();
00048 
00049       MessageAppendIterator( Message& message );
00050 
00051       MessageAppendIterator( DBusCxxPointer<Message> message );
00052 
00053       ~MessageAppendIterator();
00054 
00059       const Message* message() const;
00060 
00062       DBusMessageIter* cobj();
00063 
00065       bool init( Message& message );
00066 
00068       void invalidate();
00069 
00071       bool is_valid() const;
00072 
00074       operator bool() const;
00075 
00076       bool append( bool v );
00077       bool append( uint8_t v );
00078       bool append( int16_t v );
00079       bool append( uint16_t v );
00080       bool append( int32_t v );
00081       bool append( uint32_t v );
00082       bool append( int64_t v );
00083       bool append( uint64_t v );
00084       bool append( double v );
00085       bool append( const char* v );
00086       bool append( const std::string& v );
00087       bool append( const Signature& v );
00088 
00089       MessageAppendIterator& operator<<( bool v );
00090       MessageAppendIterator& operator<<( uint8_t v );
00091       MessageAppendIterator& operator<<( int16_t v );
00092       MessageAppendIterator& operator<<( uint16_t v );
00093       MessageAppendIterator& operator<<( int32_t v );
00094       MessageAppendIterator& operator<<( uint32_t v );
00095       MessageAppendIterator& operator<<( int64_t v );
00096       MessageAppendIterator& operator<<( uint64_t v );
00097       MessageAppendIterator& operator<<( double v );
00098       MessageAppendIterator& operator<<( const char* v );
00099       MessageAppendIterator& operator<<( const std::string& v );
00100       MessageAppendIterator& operator<<( const Signature& v );
00101 
00102 //       void append( const std::string& v );
00103 
00104 //           template <typename T0>
00105 //           void append(const Struct<T0>& s) {
00106 //             this->open_container( CONTAINER_STRUCT, std::string() );
00107 //             m_subiter->append( boost::get<0>(s) );
00108 //             this->close_container();
00109 //           }
00110       //
00111 //           template <typename T0, typename T1>
00112 //           void append(const Struct<T0,T1>& s) {
00113 //             this->open_container( CONTAINER_STRUCT, std::string() );
00114 //             m_subiter->append( boost::get<0>(s) );
00115 //             m_subiter->append( boost::get<1>(s) );
00116 //             this->close_container();
00117 //           }
00118       //
00119 //           template <typename T0, typename T1, typename T2>
00120 //           void append(const Struct<T0,T1,T2>& s) {
00121 //             this->open_container( CONTAINER_STRUCT, std::string() );
00122 //             m_subiter->append( boost::get<0>(s) );
00123 //             m_subiter->append( boost::get<1>(s) );
00124 //             m_subiter->append( boost::get<2>(s) );
00125 //             this->close_container();
00126 //           }
00127       //
00128 //           template <typename T0, typename T1, typename T2, typename T3>
00129 //           void append(const Struct<T0,T1,T2,T3>& s) {
00130 //             this->open_container( CONTAINER_STRUCT, std::string() );
00131 //             m_subiter->append( boost::get<0>(s) );
00132 //             m_subiter->append( boost::get<1>(s) );
00133 //             m_subiter->append( boost::get<2>(s) );
00134 //             m_subiter->append( boost::get<3>(s) );
00135 //             this->close_container();
00136 //           }
00137       //
00138 //           template <typename T0, typename T1, typename T2, typename T3, typename T4>
00139 //           void append(const Struct<T0,T1,T2,T3,T4>& s) {
00140 //             this->open_container( CONTAINER_STRUCT, std::string() );
00141 //             m_subiter->append( boost::get<0>(s) );
00142 //             m_subiter->append( boost::get<1>(s) );
00143 //             m_subiter->append( boost::get<2>(s) );
00144 //             m_subiter->append( boost::get<3>(s) );
00145 //             m_subiter->append( boost::get<4>(s) );
00146 //             this->close_container();
00147 //           }
00148       //
00149 //           template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
00150 //           void append(const Struct<T0,T1,T2,T3,T4,T5>& s) {
00151 //             this->open_container( CONTAINER_STRUCT, std::string() );
00152 //             m_subiter->append( boost::get<0>(s) );
00153 //             m_subiter->append( boost::get<1>(s) );
00154 //             m_subiter->append( boost::get<2>(s) );
00155 //             m_subiter->append( boost::get<3>(s) );
00156 //             m_subiter->append( boost::get<4>(s) );
00157 //             m_subiter->append( boost::get<5>(s) );
00158 //             this->close_container();
00159 //           }
00160       //
00161 //           template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00162 //           void append(const Struct<T0,T1,T2,T3,T4,T5,T6>& s) {
00163 //             this->open_container( CONTAINER_STRUCT, std::string() );
00164 //             m_subiter->append( boost::get<0>(s) );
00165 //             m_subiter->append( boost::get<1>(s) );
00166 //             m_subiter->append( boost::get<2>(s) );
00167 //             m_subiter->append( boost::get<3>(s) );
00168 //             m_subiter->append( boost::get<4>(s) );
00169 //             m_subiter->append( boost::get<5>(s) );
00170 //             m_subiter->append( boost::get<6>(s) );
00171 //             this->close_container();
00172 //           }
00173 
00174 //       template <typename T>
00175 //       void append( const std::vector<T>& v ) {
00176 //         T t;
00177 //         this->open_container( CONTAINER_ARRAY, DBus::signature( t ).c_str() );
00178 //
00179 //         for ( int i=0; i < v.size(); i++ )
00180 //           m_subiter->append( v[i] );
00181 //
00182 //         this->close_container();
00183 //       }
00184 
00185 //       template <typename Key, typename Data>
00186 //       void append( const std::vector<std::pair<Key,Data> >& dictionary ) {
00187 //         std::string sig = signature( dictionary );
00188 //         sig.erase( 0 );
00189 //         this->open_container( CONTAINER_ARRAY, sig );
00190 //         for ( int i = 0; i != dictionary.size(); i++ ) {
00191 //           m_subiter->open_container( CONTAINER_DICT_ENTRY, std::string() );
00192 //           m_subiter->m_subiter->append( dictionary[i].first );
00193 //           m_subiter->m_subiter->append( dictionary[i].second );
00194 //           m_subiter->close_container();
00195 //         }
00196 //         this->close_container();
00197 //       }
00198 
00199 //       void append_path( const std::string& v );
00200 
00201 //       void append_path( const char* v );
00202 
00203 //       void open_container( ContainerType t, const std::string& contained_signature );
00204 
00205 //       void close_container( );
00206 
00207 //       MessageAppendIterator* sub_iterator();
00208 
00209 //           bool append_path( const char* chars );
00210 
00211 //           bool append_array( char type, const void* ptr, size_t length );
00212 
00213 //           iterator new_array( const char* sig );
00214 
00215 //           iterator new_variant( const char* sig );
00216 
00217 //           iterator new_struct();
00218 
00219 //           iterator new_dict_entry();
00220 
00221 //           void close_container( iterator& container );
00222 
00223     protected:
00224       Message* m_message;
00225       DBusMessageIter m_cobj;
00226       MessageAppendIterator* m_subiter;
00227 
00228       template <typename T> bool protected_append( const T& v );
00229       bool protected_append( const bool& v );
00230       bool protected_append( const std::string& v );
00231       bool protected_append( const Signature& v );
00232 
00233   };
00234 
00235 }
00236 
00237 #endif
00238 

Generated on Thu May 28 16:50:50 2009 for dbus-cxx by doxygen 1.5.7.1