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 bool append( const Path& v ); 00089 00090 bool append( char v ); 00091 bool append( int8_t v ); 00092 bool append( float v ); 00093 #if DBUS_CXX_SIZEOF_LONG_INT == 4 00094 bool append( long int v ); 00095 bool append( long unsigned int v ); 00096 #endif 00097 00098 template <typename T> 00099 MessageAppendIterator& operator<<( T& v ) 00100 { 00101 this->append( v ); 00102 return *this; 00103 } 00104 00105 00106 // template <typename T0, typename T1> 00107 // void append(const Struct<T0,T1>& s) { 00108 // this->open_container( CONTAINER_STRUCT, std::string() ); 00109 // m_subiter->append( boost::get<0>(s) ); 00110 // m_subiter->append( boost::get<1>(s) ); 00111 // this->close_container(); 00112 // } 00113 // 00114 // template <typename T0, typename T1, typename T2> 00115 // void append(const Struct<T0,T1,T2>& s) { 00116 // this->open_container( CONTAINER_STRUCT, std::string() ); 00117 // m_subiter->append( boost::get<0>(s) ); 00118 // m_subiter->append( boost::get<1>(s) ); 00119 // m_subiter->append( boost::get<2>(s) ); 00120 // this->close_container(); 00121 // } 00122 // 00123 // template <typename T0, typename T1, typename T2, typename T3> 00124 // void append(const Struct<T0,T1,T2,T3>& s) { 00125 // this->open_container( CONTAINER_STRUCT, std::string() ); 00126 // m_subiter->append( boost::get<0>(s) ); 00127 // m_subiter->append( boost::get<1>(s) ); 00128 // m_subiter->append( boost::get<2>(s) ); 00129 // m_subiter->append( boost::get<3>(s) ); 00130 // this->close_container(); 00131 // } 00132 // 00133 // template <typename T0, typename T1, typename T2, typename T3, typename T4> 00134 // void append(const Struct<T0,T1,T2,T3,T4>& s) { 00135 // this->open_container( CONTAINER_STRUCT, std::string() ); 00136 // m_subiter->append( boost::get<0>(s) ); 00137 // m_subiter->append( boost::get<1>(s) ); 00138 // m_subiter->append( boost::get<2>(s) ); 00139 // m_subiter->append( boost::get<3>(s) ); 00140 // m_subiter->append( boost::get<4>(s) ); 00141 // this->close_container(); 00142 // } 00143 // 00144 // template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 00145 // void append(const Struct<T0,T1,T2,T3,T4,T5>& s) { 00146 // this->open_container( CONTAINER_STRUCT, std::string() ); 00147 // m_subiter->append( boost::get<0>(s) ); 00148 // m_subiter->append( boost::get<1>(s) ); 00149 // m_subiter->append( boost::get<2>(s) ); 00150 // m_subiter->append( boost::get<3>(s) ); 00151 // m_subiter->append( boost::get<4>(s) ); 00152 // m_subiter->append( boost::get<5>(s) ); 00153 // this->close_container(); 00154 // } 00155 // 00156 // template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00157 // void append(const Struct<T0,T1,T2,T3,T4,T5,T6>& s) { 00158 // this->open_container( CONTAINER_STRUCT, std::string() ); 00159 // m_subiter->append( boost::get<0>(s) ); 00160 // m_subiter->append( boost::get<1>(s) ); 00161 // m_subiter->append( boost::get<2>(s) ); 00162 // m_subiter->append( boost::get<3>(s) ); 00163 // m_subiter->append( boost::get<4>(s) ); 00164 // m_subiter->append( boost::get<5>(s) ); 00165 // m_subiter->append( boost::get<6>(s) ); 00166 // this->close_container(); 00167 // } 00168 00169 // template <typename T> 00170 // void append( const std::vector<T>& v ) { 00171 // T t; 00172 // this->open_container( CONTAINER_ARRAY, DBus::signature( t ).c_str() ); 00173 // 00174 // for ( int i=0; i < v.size(); i++ ) 00175 // m_subiter->append( v[i] ); 00176 // 00177 // this->close_container(); 00178 // } 00179 00180 // template <typename Key, typename Data> 00181 // void append( const std::vector<std::pair<Key,Data> >& dictionary ) { 00182 // std::string sig = signature( dictionary ); 00183 // sig.erase( 0 ); 00184 // this->open_container( CONTAINER_ARRAY, sig ); 00185 // for ( int i = 0; i != dictionary.size(); i++ ) { 00186 // m_subiter->open_container( CONTAINER_DICT_ENTRY, std::string() ); 00187 // m_subiter->m_subiter->append( dictionary[i].first ); 00188 // m_subiter->m_subiter->append( dictionary[i].second ); 00189 // m_subiter->close_container(); 00190 // } 00191 // this->close_container(); 00192 // } 00193 00194 // void open_container( ContainerType t, const std::string& contained_signature ); 00195 00196 // void close_container( ); 00197 00198 // MessageAppendIterator* sub_iterator(); 00199 00200 // bool append_array( char type, const void* ptr, size_t length ); 00201 00202 // iterator new_array( const char* sig ); 00203 00204 // iterator new_variant( const char* sig ); 00205 00206 // iterator new_struct(); 00207 00208 // iterator new_dict_entry(); 00209 00210 // void close_container( iterator& container ); 00211 00212 protected: 00213 Message* m_message; 00214 DBusMessageIter m_cobj; 00215 MessageAppendIterator* m_subiter; 00216 00217 template <typename T> bool protected_append( const T& v ); 00218 bool protected_append( const bool& v ); 00219 bool protected_append( const std::string& v ); 00220 bool protected_append( const Signature& v ); 00221 bool protected_append( const Path& v ); 00222 00223 }; 00224 00225 } 00226 00227 #endif 00228