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