libs/glibmm2/gio/giomm/datainputstream.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <giomm/datainputstream.h>
   5 #include <giomm/private/datainputstream_p.h>
   6
   7 // -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   8
   9 /* Copyright (C) 2007 The gtkmm Development Team
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public
  22  * License along with this library; if not, write to the Free
  23  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include <gio/gio.h>
  27 #include "slot_async.h"
  28
  29 namespace Gio
  30 {
  31
  32 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  33 guchar DataInputStream::read_byte()
  34 #else
  35 guchar DataInputStream::read_byte(std::auto_ptr<Glib::Error>& error)
  36 #endif //GLIBMM_EXCEPTIONS_ENABLED
  37 {
  38   GError* gerror = 0;
  39   guchar retvalue = g_data_input_stream_read_byte(gobj(), NULL, &(gerror));
  40 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  41   if(gerror)
  42     ::Glib::Error::throw_exception(gerror);
  43 #else
  44   if(gerror)
  45     error = ::Glib::Error::throw_exception(gerror);
  46 #endif //GLIBMM_EXCEPTIONS_ENABLED
  47
  48   return retvalue;
  49 }
  50
  51 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  52 gint16 DataInputStream::read_int16()
  53 #else
  54 gint16 DataInputStream::read_int16(std::auto_ptr<Glib::Error>& error)
  55 #endif //GLIBMM_EXCEPTIONS_ENABLED
  56 {
  57   GError* gerror = 0;
  58   gint16 retvalue = g_data_input_stream_read_int16(gobj(), NULL, &(gerror));
  59 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  60   if(gerror)
  61     ::Glib::Error::throw_exception(gerror);
  62 #else
  63   if(gerror)
  64     error = ::Glib::Error::throw_exception(gerror);
  65 #endif //GLIBMM_EXCEPTIONS_ENABLED
  66
  67   return retvalue;
  68 }
  69
  70 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  71 guint16 DataInputStream::read_uint16()
  72 #else
  73 guint16 DataInputStream::read_uint16(std::auto_ptr<Glib::Error>& error)
  74 #endif //GLIBMM_EXCEPTIONS_ENABLED
  75 {
  76   GError* gerror = 0;
  77   guint16 retvalue = g_data_input_stream_read_uint16(gobj(), NULL, &(gerror));
  78 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  79   if(gerror)
  80     ::Glib::Error::throw_exception(gerror);
  81 #else
  82   if(gerror)
  83     error = ::Glib::Error::throw_exception(gerror);
  84 #endif //GLIBMM_EXCEPTIONS_ENABLED
  85
  86   return retvalue;
  87 }
  88
  89 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  90 gint32 DataInputStream::read_int32()
  91 #else
  92 gint32 DataInputStream::read_int32(std::auto_ptr<Glib::Error>& error)
  93 #endif //GLIBMM_EXCEPTIONS_ENABLED
  94 {
  95   GError* gerror = 0;
  96   gint32 retvalue = g_data_input_stream_read_int32(gobj(), NULL, &(gerror));
  97 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  98   if(gerror)
  99     ::Glib::Error::throw_exception(gerror);
 100 #else
 101   if(gerror)
 102     error = ::Glib::Error::throw_exception(gerror);
 103 #endif //GLIBMM_EXCEPTIONS_ENABLED
 104
 105   return retvalue;
 106 }
 107
 108 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 109 guint32 DataInputStream::read_uint32()
 110 #else
 111 guint32 DataInputStream::read_uint32(std::auto_ptr<Glib::Error>& error)
 112 #endif //GLIBMM_EXCEPTIONS_ENABLED
 113 {
 114   GError* gerror = 0;
 115   guint32 retvalue = g_data_input_stream_read_uint32(gobj(), NULL, &(gerror));
 116 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 117   if(gerror)
 118     ::Glib::Error::throw_exception(gerror);
 119 #else
 120   if(gerror)
 121     error = ::Glib::Error::throw_exception(gerror);
 122 #endif //GLIBMM_EXCEPTIONS_ENABLED
 123
 124   return retvalue;
 125 }
 126
 127 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 128 gint64 DataInputStream::read_int64()
 129 #else
 130 gint64 DataInputStream::read_int64(std::auto_ptr<Glib::Error>& error)
 131 #endif //GLIBMM_EXCEPTIONS_ENABLED
 132 {
 133   GError* gerror = 0;
 134   gint64 retvalue = g_data_input_stream_read_int64(gobj(), NULL, &(gerror));
 135 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 136   if(gerror)
 137     ::Glib::Error::throw_exception(gerror);
 138 #else
 139   if(gerror)
 140     error = ::Glib::Error::throw_exception(gerror);
 141 #endif //GLIBMM_EXCEPTIONS_ENABLED
 142
 143   return retvalue;
 144 }
 145
 146 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 147 guint64 DataInputStream::read_uint64()
 148 #else
 149 guint64 DataInputStream::read_uint64(std::auto_ptr<Glib::Error>& error)
 150 #endif //GLIBMM_EXCEPTIONS_ENABLED
 151 {
 152   GError* gerror = 0;
 153   guint64 retvalue = g_data_input_stream_read_uint64(gobj(), NULL, &(gerror));
 154 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 155   if(gerror)
 156     ::Glib::Error::throw_exception(gerror);
 157 #else
 158   if(gerror)
 159     error = ::Glib::Error::throw_exception(gerror);
 160 #endif //GLIBMM_EXCEPTIONS_ENABLED
 161
 162   return retvalue;
 163 }
 164
 165 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 166 bool DataInputStream::read_line(std::string& line, const Glib::RefPtr<Cancellable>& cancellable)
 167 #else
 168 bool DataInputStream::read_line(std::string& line, const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 169 #endif //GLIBMM_EXCEPTIONS_ENABLED
 170 {
 171   GError* gerror = 0;
 172   char* c_line = g_data_input_stream_read_line(gobj(),
 173                                                NULL, // pass NULL since we can easily determine the length from the returned std::string
 174                                                cancellable->gobj(),
 175                                                &gerror);
 176 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 177   if(gerror)
 178     ::Glib::Error::throw_exception(gerror);
 179 #else
 180   if(gerror)
 181     error = ::Glib::Error::throw_exception(gerror);
 182 #endif //GLIBMM_EXCEPTIONS_ENABLED
 183     if (c_line) {
 184         line = c_line;
 185         g_free (c_line);
 186         return true;
 187     }
 188     // end of stream reached, return failure status
 189     return false;
 190 }
 191
 192 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 193 bool DataInputStream::read_line(std::string& line)
 194 #else
 195 bool DataInputStream::read_line(std::string& line, std::auto_ptr<Glib::Error>& error)
 196 #endif //GLIBMM_EXCEPTIONS_ENABLED
 197 {
 198   GError* gerror = 0;
 199   char* c_line = g_data_input_stream_read_line(gobj(),
 200                                                NULL, // pass NULL since we can easily determine the length from the returned std::string
 201                                                NULL,
 202                                                &gerror);
 203 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 204   if(gerror)
 205     ::Glib::Error::throw_exception(gerror);
 206 #else
 207   if(gerror)
 208     error = ::Glib::Error::throw_exception(gerror);
 209 #endif //GLIBMM_EXCEPTIONS_ENABLED
 210     if (c_line) {
 211         line = c_line;
 212         g_free(c_line);
 213         return true;
 214     }
 215     // end of stream reached, return failure status
 216     return false;
 217 }
 218
 219
 220 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 221 bool DataInputStream::read_until(std::string& data, const std::string& stop_chars, const Glib::RefPtr<Cancellable>& cancellable)
 222 #else
 223 bool DataInputStream::read_until(std::string& data, const std::string& stop_chars, const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 224 #endif //GLIBMM_EXCEPTIONS_ENABLED
 225 {
 226   GError* gerror = 0;
 227   char* c_str = g_data_input_stream_read_until(gobj(),
 228                                                stop_chars.c_str(),
 229                                                NULL, // pass NULL since we can easily determine the length from the returned std::string
 230                                                cancellable->gobj(),
 231                                                &gerror);
 232 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 233   if(gerror)
 234     ::Glib::Error::throw_exception(gerror);
 235 #else
 236   if(gerror)
 237     error = ::Glib::Error::throw_exception(gerror);
 238 #endif //GLIBMM_EXCEPTIONS_ENABLED
 239     if (c_str) {
 240         data = c_str;
 241         g_free (c_str);
 242         return true;
 243     }
 244     // end of stream reached, return failure status
 245     return false;
 246 }
 247
 248 /** non-cancellable version of read_until()
 249  */
 250 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 251 bool DataInputStream::read_until(std::string& data, const std::string& stop_chars)
 252 #else
 253 bool DataInputStream::read_until(std::string& data, const std::string& stop_chars, std::auto_ptr<Glib::Error>& error)
 254 #endif //GLIBMM_EXCEPTIONS_ENABLED
 255 {
 256   GError* gerror = 0;
 257   char* c_str = g_data_input_stream_read_until(gobj(),
 258                                                stop_chars.c_str(),
 259                                                NULL, // pass NULL since we can easily determine the length from the returned std::string
 260                                                NULL,
 261                                                &gerror);
 262 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 263   if(gerror)
 264     ::Glib::Error::throw_exception(gerror);
 265 #else
 266   if(gerror)
 267     error = ::Glib::Error::throw_exception(gerror);
 268 #endif //GLIBMM_EXCEPTIONS_ENABLED
 269     if (c_str) {
 270         data = c_str;
 271         g_free (c_str);
 272         return true;
 273     }
 274     // end of stream reached, return failure status
 275     return false;
 276 }
 277
 278 } // namespace Gio
 279
 280 namespace
 281 {
 282 } // anonymous namespace
 283
 284
 285 namespace Glib
 286 {
 287
 288 Glib::RefPtr<Gio::DataInputStream> wrap(GDataInputStream* object, bool take_copy)
 289 {
 290   return Glib::RefPtr<Gio::DataInputStream>( dynamic_cast<Gio::DataInputStream*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
 291   //We use dynamic_cast<> in case of multiple inheritance.
 292 }
 293
 294 } /* namespace Glib */
 295
 296
 297 namespace Gio
 298 {
 299
 300
 301 /* The *_Class implementation: */
 302
 303 const Glib::Class& DataInputStream_Class::init()
 304 {
 305   if(!gtype_) // create the GType if necessary
 306   {
 307     // Glib::Class has to know the class init function to clone custom types.
 308     class_init_func_ = &DataInputStream_Class::class_init_function;
 309
 310     // This is actually just optimized away, apparently with no harm.
 311     // Make sure that the parent type has been created.
 312     //CppClassParent::CppObjectType::get_type();
 313
 314     // Create the wrapper type, with the same class/instance size as the base type.
 315     register_derived_type(g_data_input_stream_get_type());
 316
 317     // Add derived versions of interfaces, if the C type implements any interfaces:
 318
 319   }
 320
 321   return *this;
 322 }
 323
 324 void DataInputStream_Class::class_init_function(void* g_class, void* class_data)
 325 {
 326   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 327   CppClassParent::class_init_function(klass, class_data);
 328
 329 #ifdef GLIBMM_VFUNCS_ENABLED
 330 #endif //GLIBMM_VFUNCS_ENABLED
 331
 332 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 333 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 334 }
 335
 336 #ifdef GLIBMM_VFUNCS_ENABLED
 337 #endif //GLIBMM_VFUNCS_ENABLED
 338
 339 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 340 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 341
 342
 343 Glib::ObjectBase* DataInputStream_Class::wrap_new(GObject* object)
 344 {
 345   return new DataInputStream((GDataInputStream*)object);
 346 }
 347
 348
 349 /* The implementation: */
 350
 351 GDataInputStream* DataInputStream::gobj_copy()
 352 {
 353   reference();
 354   return gobj();
 355 }
 356
 357 DataInputStream::DataInputStream(const Glib::ConstructParams& construct_params)
 358 :
 359   Gio::BufferedInputStream(construct_params)
 360 {
 361
 362 }
 363
 364 DataInputStream::DataInputStream(GDataInputStream* castitem)
 365 :
 366   Gio::BufferedInputStream((GBufferedInputStream*)(castitem))
 367 {}
 368
 369
 370 DataInputStream::~DataInputStream()
 371 {}
 372
 373
 374 DataInputStream::CppClassType DataInputStream::datainputstream_class_; // initialize static member
 375
 376 GType DataInputStream::get_type()
 377 {
 378   return datainputstream_class_.init().get_type();
 379 }
 380
 381 GType DataInputStream::get_base_type()
 382 {
 383   return g_data_input_stream_get_type();
 384 }
 385
 386
 387 DataInputStream::DataInputStream(const Glib::RefPtr<InputStream>& base_stream)
 388 :
 389   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 390   Glib::ObjectBase(0),
 391   Gio::BufferedInputStream(Glib::ConstructParams(datainputstream_class_.init(), "base_stream", const_cast<GInputStream*>(Glib::unwrap(base_stream)), static_cast<char*>(0)))
 392 {
 393
 394
 395 }
 396
 397 Glib::RefPtr<DataInputStream> DataInputStream::create(const Glib::RefPtr<InputStream>& base_stream)
 398 {
 399   return Glib::RefPtr<DataInputStream>( new DataInputStream(base_stream) );
 400 }
 401 void DataInputStream::set_byte_order(DataStreamByteOrder order)
 402 {
 403 g_data_input_stream_set_byte_order(gobj(), ((GDataStreamByteOrder)(order)));
 404 }
 405
 406 DataStreamByteOrder DataInputStream::get_byte_order() const
 407 {
 408   return ((DataStreamByteOrder)(g_data_input_stream_get_byte_order(const_cast<GDataInputStream*>(gobj()))));
 409 }
 410
 411 void DataInputStream::set_newline_type(DataStreamNewlineType type)
 412 {
 413 g_data_input_stream_set_newline_type(gobj(), ((GDataStreamNewlineType)(type)));
 414 }
 415
 416 DataStreamNewlineType DataInputStream::get_newline_type() const
 417 {
 418   return ((DataStreamNewlineType)(g_data_input_stream_get_newline_type(const_cast<GDataInputStream*>(gobj()))));
 419 }
 420
 421 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 422 guchar DataInputStream::read_byte(const Glib::RefPtr<Cancellable>& cancellable)
 423 #else
 424 guchar DataInputStream::read_byte(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 425 #endif //GLIBMM_EXCEPTIONS_ENABLED
 426 {
 427   GError* gerror = 0;
 428   guchar retvalue = g_data_input_stream_read_byte(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 429 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 430   if(gerror)
 431     ::Glib::Error::throw_exception(gerror);
 432 #else
 433   if(gerror)
 434     error = ::Glib::Error::throw_exception(gerror);
 435 #endif //GLIBMM_EXCEPTIONS_ENABLED
 436
 437   return retvalue;
 438
 439 }
 440
 441 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 442 gint16 DataInputStream::read_int16(const Glib::RefPtr<Cancellable>& cancellable)
 443 #else
 444 gint16 DataInputStream::read_int16(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 445 #endif //GLIBMM_EXCEPTIONS_ENABLED
 446 {
 447   GError* gerror = 0;
 448   gint16 retvalue = g_data_input_stream_read_int16(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 449 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 450   if(gerror)
 451     ::Glib::Error::throw_exception(gerror);
 452 #else
 453   if(gerror)
 454     error = ::Glib::Error::throw_exception(gerror);
 455 #endif //GLIBMM_EXCEPTIONS_ENABLED
 456
 457   return retvalue;
 458
 459 }
 460
 461 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 462 guint16 DataInputStream::read_uint16(const Glib::RefPtr<Cancellable>& cancellable)
 463 #else
 464 guint16 DataInputStream::read_uint16(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 465 #endif //GLIBMM_EXCEPTIONS_ENABLED
 466 {
 467   GError* gerror = 0;
 468   guint16 retvalue = g_data_input_stream_read_uint16(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 469 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 470   if(gerror)
 471     ::Glib::Error::throw_exception(gerror);
 472 #else
 473   if(gerror)
 474     error = ::Glib::Error::throw_exception(gerror);
 475 #endif //GLIBMM_EXCEPTIONS_ENABLED
 476
 477   return retvalue;
 478
 479 }
 480
 481 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 482 gint32 DataInputStream::read_int32(const Glib::RefPtr<Cancellable>& cancellable)
 483 #else
 484 gint32 DataInputStream::read_int32(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 485 #endif //GLIBMM_EXCEPTIONS_ENABLED
 486 {
 487   GError* gerror = 0;
 488   gint32 retvalue = g_data_input_stream_read_int32(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 489 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 490   if(gerror)
 491     ::Glib::Error::throw_exception(gerror);
 492 #else
 493   if(gerror)
 494     error = ::Glib::Error::throw_exception(gerror);
 495 #endif //GLIBMM_EXCEPTIONS_ENABLED
 496
 497   return retvalue;
 498
 499 }
 500
 501 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 502 guint32 DataInputStream::read_uint32(const Glib::RefPtr<Cancellable>& cancellable)
 503 #else
 504 guint32 DataInputStream::read_uint32(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 505 #endif //GLIBMM_EXCEPTIONS_ENABLED
 506 {
 507   GError* gerror = 0;
 508   guint32 retvalue = g_data_input_stream_read_uint32(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 509 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 510   if(gerror)
 511     ::Glib::Error::throw_exception(gerror);
 512 #else
 513   if(gerror)
 514     error = ::Glib::Error::throw_exception(gerror);
 515 #endif //GLIBMM_EXCEPTIONS_ENABLED
 516
 517   return retvalue;
 518
 519 }
 520
 521 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 522 gint64 DataInputStream::read_int64(const Glib::RefPtr<Cancellable>& cancellable)
 523 #else
 524 gint64 DataInputStream::read_int64(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 525 #endif //GLIBMM_EXCEPTIONS_ENABLED
 526 {
 527   GError* gerror = 0;
 528   gint64 retvalue = g_data_input_stream_read_int64(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 529 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 530   if(gerror)
 531     ::Glib::Error::throw_exception(gerror);
 532 #else
 533   if(gerror)
 534     error = ::Glib::Error::throw_exception(gerror);
 535 #endif //GLIBMM_EXCEPTIONS_ENABLED
 536
 537   return retvalue;
 538
 539 }
 540
 541 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 542 guint64 DataInputStream::read_uint64(const Glib::RefPtr<Cancellable>& cancellable)
 543 #else
 544 guint64 DataInputStream::read_uint64(const Glib::RefPtr<Cancellable>& cancellable, std::auto_ptr<Glib::Error>& error)
 545 #endif //GLIBMM_EXCEPTIONS_ENABLED
 546 {
 547   GError* gerror = 0;
 548   guint64 retvalue = g_data_input_stream_read_uint64(gobj(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
 549 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 550   if(gerror)
 551     ::Glib::Error::throw_exception(gerror);
 552 #else
 553   if(gerror)
 554     error = ::Glib::Error::throw_exception(gerror);
 555 #endif //GLIBMM_EXCEPTIONS_ENABLED
 556
 557   return retvalue;
 558
 559 }
 560
 561
 562 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 563 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 564
 565 #ifdef GLIBMM_VFUNCS_ENABLED
 566 #endif //GLIBMM_VFUNCS_ENABLED
 567
 568
 569 } // namespace Gio
 570
 571