| OLD | NEW |
| (Empty) |
| 1 /* | |
| 2 * This file was automatically generated by dbusxx-xml2cpp; DO NOT EDIT! | |
| 3 */ | |
| 4 #ifndef __dbusxx__mtpd_server_mtpd_server_h__ADAPTOR_MARSHALL_H | |
| 5 #define __dbusxx__mtpd_server_mtpd_server_h__ADAPTOR_MARSHALL_H | |
| 6 #include <dbus-c++/dbus.h> | |
| 7 #include <cassert> | |
| 8 | |
| 9 namespace org { | |
| 10 namespace chromium { | |
| 11 | |
| 12 class Mtpd_adaptor | |
| 13 : public ::DBus::InterfaceAdaptor | |
| 14 { | |
| 15 public: | |
| 16 Mtpd_adaptor() | |
| 17 : ::DBus::InterfaceAdaptor("org.chromium.Mtpd") | |
| 18 { | |
| 19 register_method(Mtpd_adaptor, EnumerateStorages, _EnumerateStorages_stub
); | |
| 20 register_method(Mtpd_adaptor, GetStorageInfo, _GetStorageInfo_stub); | |
| 21 register_method(Mtpd_adaptor, OpenStorage, _OpenStorage_stub); | |
| 22 register_method(Mtpd_adaptor, CloseStorage, _CloseStorage_stub); | |
| 23 register_method(Mtpd_adaptor, ReadDirectoryByPath, _ReadDirectoryByPath_
stub); | |
| 24 register_method(Mtpd_adaptor, ReadDirectoryById, _ReadDirectoryById_stub
); | |
| 25 register_method(Mtpd_adaptor, ReadFileChunkByPath, _ReadFileChunkByPath_
stub); | |
| 26 register_method(Mtpd_adaptor, ReadFileChunkById, _ReadFileChunkById_stub
); | |
| 27 register_method(Mtpd_adaptor, GetFileInfoByPath, _GetFileInfoByPath_stub
); | |
| 28 register_method(Mtpd_adaptor, GetFileInfoById, _GetFileInfoById_stub); | |
| 29 register_method(Mtpd_adaptor, IsAlive, _IsAlive_stub); | |
| 30 } | |
| 31 const ::DBus::IntrospectedInterface *introspect() const | |
| 32 { | |
| 33 static const ::DBus::IntrospectedArgument EnumerateStorages_args[] = | |
| 34 { | |
| 35 { "storageList", "as", false }, | |
| 36 { 0, 0, 0 } | |
| 37 }; | |
| 38 static const ::DBus::IntrospectedArgument GetStorageInfo_args[] = | |
| 39 { | |
| 40 { "storageName", "s", true }, | |
| 41 { "storageInfo", "ay", false }, | |
| 42 { 0, 0, 0 } | |
| 43 }; | |
| 44 static const ::DBus::IntrospectedArgument OpenStorage_args[] = | |
| 45 { | |
| 46 { "storageName", "s", true }, | |
| 47 { "mode", "s", true }, | |
| 48 { "handle", "s", false }, | |
| 49 { 0, 0, 0 } | |
| 50 }; | |
| 51 static const ::DBus::IntrospectedArgument CloseStorage_args[] = | |
| 52 { | |
| 53 { "handle", "s", true }, | |
| 54 { 0, 0, 0 } | |
| 55 }; | |
| 56 static const ::DBus::IntrospectedArgument ReadDirectoryByPath_args[] = | |
| 57 { | |
| 58 { "handle", "s", true }, | |
| 59 { "filePath", "s", true }, | |
| 60 { "results", "ay", false }, | |
| 61 { 0, 0, 0 } | |
| 62 }; | |
| 63 static const ::DBus::IntrospectedArgument ReadDirectoryById_args[] = | |
| 64 { | |
| 65 { "handle", "s", true }, | |
| 66 { "fileId", "u", true }, | |
| 67 { "results", "ay", false }, | |
| 68 { 0, 0, 0 } | |
| 69 }; | |
| 70 static const ::DBus::IntrospectedArgument ReadFileChunkByPath_args[] = | |
| 71 { | |
| 72 { "handle", "s", true }, | |
| 73 { "filePath", "s", true }, | |
| 74 { "offset", "u", true }, | |
| 75 { "count", "u", true }, | |
| 76 { "data", "ay", false }, | |
| 77 { 0, 0, 0 } | |
| 78 }; | |
| 79 static const ::DBus::IntrospectedArgument ReadFileChunkById_args[] = | |
| 80 { | |
| 81 { "handle", "s", true }, | |
| 82 { "fileId", "u", true }, | |
| 83 { "offset", "u", true }, | |
| 84 { "count", "u", true }, | |
| 85 { "data", "ay", false }, | |
| 86 { 0, 0, 0 } | |
| 87 }; | |
| 88 static const ::DBus::IntrospectedArgument GetFileInfoByPath_args[] = | |
| 89 { | |
| 90 { "handle", "s", true }, | |
| 91 { "filePath", "s", true }, | |
| 92 { "info", "ay", false }, | |
| 93 { 0, 0, 0 } | |
| 94 }; | |
| 95 static const ::DBus::IntrospectedArgument GetFileInfoById_args[] = | |
| 96 { | |
| 97 { "handle", "s", true }, | |
| 98 { "fileId", "u", true }, | |
| 99 { "info", "ay", false }, | |
| 100 { 0, 0, 0 } | |
| 101 }; | |
| 102 static const ::DBus::IntrospectedArgument IsAlive_args[] = | |
| 103 { | |
| 104 { "result", "b", false }, | |
| 105 { 0, 0, 0 } | |
| 106 }; | |
| 107 static const ::DBus::IntrospectedArgument MTPStorageAttached_args[] = | |
| 108 { | |
| 109 { "storageName", "s", false }, | |
| 110 { 0, 0, 0 } | |
| 111 }; | |
| 112 static const ::DBus::IntrospectedArgument MTPStorageDetached_args[] = | |
| 113 { | |
| 114 { "storageName", "s", false }, | |
| 115 { 0, 0, 0 } | |
| 116 }; | |
| 117 static const ::DBus::IntrospectedMethod Mtpd_adaptor_methods[] = | |
| 118 { | |
| 119 { "EnumerateStorages", EnumerateStorages_args }, | |
| 120 { "GetStorageInfo", GetStorageInfo_args }, | |
| 121 { "OpenStorage", OpenStorage_args }, | |
| 122 { "CloseStorage", CloseStorage_args }, | |
| 123 { "ReadDirectoryByPath", ReadDirectoryByPath_args }, | |
| 124 { "ReadDirectoryById", ReadDirectoryById_args }, | |
| 125 { "ReadFileChunkByPath", ReadFileChunkByPath_args }, | |
| 126 { "ReadFileChunkById", ReadFileChunkById_args }, | |
| 127 { "GetFileInfoByPath", GetFileInfoByPath_args }, | |
| 128 { "GetFileInfoById", GetFileInfoById_args }, | |
| 129 { "IsAlive", IsAlive_args }, | |
| 130 { 0, 0 } | |
| 131 }; | |
| 132 static const ::DBus::IntrospectedMethod Mtpd_adaptor_signals[] = | |
| 133 { | |
| 134 { "MTPStorageAttached", MTPStorageAttached_args }, | |
| 135 { "MTPStorageDetached", MTPStorageDetached_args }, | |
| 136 { 0, 0 } | |
| 137 }; | |
| 138 static const ::DBus::IntrospectedProperty Mtpd_adaptor_properties[] = | |
| 139 { | |
| 140 { 0, 0, 0, 0 } | |
| 141 }; | |
| 142 static const ::DBus::IntrospectedInterface Mtpd_adaptor_interface = | |
| 143 { | |
| 144 "org.chromium.Mtpd", | |
| 145 Mtpd_adaptor_methods, | |
| 146 Mtpd_adaptor_signals, | |
| 147 Mtpd_adaptor_properties | |
| 148 }; | |
| 149 return &Mtpd_adaptor_interface; | |
| 150 } | |
| 151 /* Properties exposed by this interface. | |
| 152 * Use property() and property(value) to | |
| 153 * get and set a particular property. | |
| 154 */ | |
| 155 /* Methods exported by this interface. | |
| 156 * You will have to implement them in your ObjectAdaptor. | |
| 157 */ | |
| 158 virtual std::vector< std::string > EnumerateStorages(::DBus::Error &error) =
0; | |
| 159 virtual std::vector< uint8_t > GetStorageInfo(const std::string& storageName
, ::DBus::Error &error) = 0; | |
| 160 virtual std::string OpenStorage(const std::string& storageName, const std::s
tring& mode, ::DBus::Error &error) = 0; | |
| 161 virtual void CloseStorage(const std::string& handle, ::DBus::Error &error) =
0; | |
| 162 virtual std::vector< uint8_t > ReadDirectoryByPath(const std::string& handle
, const std::string& filePath, ::DBus::Error &error) = 0; | |
| 163 virtual std::vector< uint8_t > ReadDirectoryById(const std::string& handle,
const uint32_t& fileId, ::DBus::Error &error) = 0; | |
| 164 virtual std::vector< uint8_t > ReadFileChunkByPath(const std::string& handle
, const std::string& filePath, const uint32_t& offset, const uint32_t& count, ::
DBus::Error &error) = 0; | |
| 165 virtual std::vector< uint8_t > ReadFileChunkById(const std::string& handle,
const uint32_t& fileId, const uint32_t& offset, const uint32_t& count, ::DBus::E
rror &error) = 0; | |
| 166 virtual std::vector< uint8_t > GetFileInfoByPath(const std::string& handle,
const std::string& filePath, ::DBus::Error &error) = 0; | |
| 167 virtual std::vector< uint8_t > GetFileInfoById(const std::string& handle, co
nst uint32_t& fileId, ::DBus::Error &error) = 0; | |
| 168 virtual bool IsAlive(::DBus::Error &error) = 0; | |
| 169 /* signal emitters for this interface */ | |
| 170 void MTPStorageAttached(const std::string &storageName) | |
| 171 { | |
| 172 ::DBus::SignalMessage __sig("MTPStorageAttached"); | |
| 173 ::DBus::MessageIter __wi = __sig.writer(); | |
| 174 __wi << storageName; | |
| 175 emit_signal(__sig); | |
| 176 } | |
| 177 void MTPStorageDetached(const std::string &storageName) | |
| 178 { | |
| 179 ::DBus::SignalMessage __sig("MTPStorageDetached"); | |
| 180 ::DBus::MessageIter __wi = __sig.writer(); | |
| 181 __wi << storageName; | |
| 182 emit_signal(__sig); | |
| 183 } | |
| 184 private: | |
| 185 /* unmarshallers (to unpack the DBus message before calling the actual | |
| 186 * interface method) | |
| 187 */ | |
| 188 ::DBus::Message _EnumerateStorages_stub(const ::DBus::CallMessage &__call) | |
| 189 { | |
| 190 ::DBus::Error __error; | |
| 191 std::vector< std::string > __argout; | |
| 192 __argout = EnumerateStorages(__error); | |
| 193 if (__error.is_set()) | |
| 194 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 195 ::DBus::ReturnMessage __reply(__call); | |
| 196 ::DBus::MessageIter __wi = __reply.writer(); | |
| 197 __wi << __argout; | |
| 198 return __reply; | |
| 199 } | |
| 200 ::DBus::Message _GetStorageInfo_stub(const ::DBus::CallMessage &__call) | |
| 201 { | |
| 202 ::DBus::Error __error; | |
| 203 ::DBus::MessageIter __ri = __call.reader(); | |
| 204 std::string storageName; __ri >> storageName; | |
| 205 std::vector< uint8_t > __argout; | |
| 206 __argout = GetStorageInfo(storageName, __error); | |
| 207 if (__error.is_set()) | |
| 208 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 209 ::DBus::ReturnMessage __reply(__call); | |
| 210 ::DBus::MessageIter __wi = __reply.writer(); | |
| 211 __wi << __argout; | |
| 212 return __reply; | |
| 213 } | |
| 214 ::DBus::Message _OpenStorage_stub(const ::DBus::CallMessage &__call) | |
| 215 { | |
| 216 ::DBus::Error __error; | |
| 217 ::DBus::MessageIter __ri = __call.reader(); | |
| 218 std::string storageName; __ri >> storageName; | |
| 219 std::string mode; __ri >> mode; | |
| 220 std::string __argout; | |
| 221 __argout = OpenStorage(storageName, mode, __error); | |
| 222 if (__error.is_set()) | |
| 223 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 224 ::DBus::ReturnMessage __reply(__call); | |
| 225 ::DBus::MessageIter __wi = __reply.writer(); | |
| 226 __wi << __argout; | |
| 227 return __reply; | |
| 228 } | |
| 229 ::DBus::Message _CloseStorage_stub(const ::DBus::CallMessage &__call) | |
| 230 { | |
| 231 ::DBus::Error __error; | |
| 232 ::DBus::MessageIter __ri = __call.reader(); | |
| 233 std::string handle; __ri >> handle; | |
| 234 CloseStorage(handle, __error); | |
| 235 if (__error.is_set()) | |
| 236 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 237 ::DBus::ReturnMessage __reply(__call); | |
| 238 return __reply; | |
| 239 } | |
| 240 ::DBus::Message _ReadDirectoryByPath_stub(const ::DBus::CallMessage &__call) | |
| 241 { | |
| 242 ::DBus::Error __error; | |
| 243 ::DBus::MessageIter __ri = __call.reader(); | |
| 244 std::string handle; __ri >> handle; | |
| 245 std::string filePath; __ri >> filePath; | |
| 246 std::vector< uint8_t > __argout; | |
| 247 __argout = ReadDirectoryByPath(handle, filePath, __error); | |
| 248 if (__error.is_set()) | |
| 249 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 250 ::DBus::ReturnMessage __reply(__call); | |
| 251 ::DBus::MessageIter __wi = __reply.writer(); | |
| 252 __wi << __argout; | |
| 253 return __reply; | |
| 254 } | |
| 255 ::DBus::Message _ReadDirectoryById_stub(const ::DBus::CallMessage &__call) | |
| 256 { | |
| 257 ::DBus::Error __error; | |
| 258 ::DBus::MessageIter __ri = __call.reader(); | |
| 259 std::string handle; __ri >> handle; | |
| 260 uint32_t fileId; __ri >> fileId; | |
| 261 std::vector< uint8_t > __argout; | |
| 262 __argout = ReadDirectoryById(handle, fileId, __error); | |
| 263 if (__error.is_set()) | |
| 264 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 265 ::DBus::ReturnMessage __reply(__call); | |
| 266 ::DBus::MessageIter __wi = __reply.writer(); | |
| 267 __wi << __argout; | |
| 268 return __reply; | |
| 269 } | |
| 270 ::DBus::Message _ReadFileChunkByPath_stub(const ::DBus::CallMessage &__call) | |
| 271 { | |
| 272 ::DBus::Error __error; | |
| 273 ::DBus::MessageIter __ri = __call.reader(); | |
| 274 std::string handle; __ri >> handle; | |
| 275 std::string filePath; __ri >> filePath; | |
| 276 uint32_t offset; __ri >> offset; | |
| 277 uint32_t count; __ri >> count; | |
| 278 std::vector< uint8_t > __argout; | |
| 279 __argout = ReadFileChunkByPath(handle, filePath, offset, count, __error)
; | |
| 280 if (__error.is_set()) | |
| 281 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 282 ::DBus::ReturnMessage __reply(__call); | |
| 283 ::DBus::MessageIter __wi = __reply.writer(); | |
| 284 __wi << __argout; | |
| 285 return __reply; | |
| 286 } | |
| 287 ::DBus::Message _ReadFileChunkById_stub(const ::DBus::CallMessage &__call) | |
| 288 { | |
| 289 ::DBus::Error __error; | |
| 290 ::DBus::MessageIter __ri = __call.reader(); | |
| 291 std::string handle; __ri >> handle; | |
| 292 uint32_t fileId; __ri >> fileId; | |
| 293 uint32_t offset; __ri >> offset; | |
| 294 uint32_t count; __ri >> count; | |
| 295 std::vector< uint8_t > __argout; | |
| 296 __argout = ReadFileChunkById(handle, fileId, offset, count, __error); | |
| 297 if (__error.is_set()) | |
| 298 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 299 ::DBus::ReturnMessage __reply(__call); | |
| 300 ::DBus::MessageIter __wi = __reply.writer(); | |
| 301 __wi << __argout; | |
| 302 return __reply; | |
| 303 } | |
| 304 ::DBus::Message _GetFileInfoByPath_stub(const ::DBus::CallMessage &__call) | |
| 305 { | |
| 306 ::DBus::Error __error; | |
| 307 ::DBus::MessageIter __ri = __call.reader(); | |
| 308 std::string handle; __ri >> handle; | |
| 309 std::string filePath; __ri >> filePath; | |
| 310 std::vector< uint8_t > __argout; | |
| 311 __argout = GetFileInfoByPath(handle, filePath, __error); | |
| 312 if (__error.is_set()) | |
| 313 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 314 ::DBus::ReturnMessage __reply(__call); | |
| 315 ::DBus::MessageIter __wi = __reply.writer(); | |
| 316 __wi << __argout; | |
| 317 return __reply; | |
| 318 } | |
| 319 ::DBus::Message _GetFileInfoById_stub(const ::DBus::CallMessage &__call) | |
| 320 { | |
| 321 ::DBus::Error __error; | |
| 322 ::DBus::MessageIter __ri = __call.reader(); | |
| 323 std::string handle; __ri >> handle; | |
| 324 uint32_t fileId; __ri >> fileId; | |
| 325 std::vector< uint8_t > __argout; | |
| 326 __argout = GetFileInfoById(handle, fileId, __error); | |
| 327 if (__error.is_set()) | |
| 328 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 329 ::DBus::ReturnMessage __reply(__call); | |
| 330 ::DBus::MessageIter __wi = __reply.writer(); | |
| 331 __wi << __argout; | |
| 332 return __reply; | |
| 333 } | |
| 334 ::DBus::Message _IsAlive_stub(const ::DBus::CallMessage &__call) | |
| 335 { | |
| 336 ::DBus::Error __error; | |
| 337 bool __argout; | |
| 338 __argout = IsAlive(__error); | |
| 339 if (__error.is_set()) | |
| 340 return ::DBus::ErrorMessage(__call, __error.name(), __error.message(
)); | |
| 341 ::DBus::ReturnMessage __reply(__call); | |
| 342 ::DBus::MessageIter __wi = __reply.writer(); | |
| 343 __wi << __argout; | |
| 344 return __reply; | |
| 345 } | |
| 346 }; | |
| 347 }} | |
| 348 #endif // __dbusxx__mtpd_server_mtpd_server_h__ADAPTOR_MARSHALL_H | |
| OLD | NEW |