src/kits/media/legacy/OldBufferStream.cpp

   1 /*
   2  * Copyright 2002, Marcus Overhagen. All Rights Reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 // This is deprecated API that is not even implemented - no need to export
   8 // it on a GCC4 build (BeIDE needs it to run, though, so it's worthwhile for
   9 // GCC2)
  10 #if __GNUC__ < 3
  11
  12
  13 #include "OldBufferStream.h"
  14
  15 #include <debug.h>
  16 #include <new>
  17
  18
  19 /*************************************************************
  20  * public BAbstractBufferStream
  21  *************************************************************/
  22 status_t
  23 BAbstractBufferStream::GetStreamParameters(size_t *bufferSize,
  24                                                                                    int32 *bufferCount,
  25                                                                                    bool *isRunning,
  26                                                                                    int32 *subscriberCount) const
  27 {
  28         UNIMPLEMENTED();
  29
  30         return B_ERROR;
  31 }
  32
  33
  34 status_t
  35 BAbstractBufferStream::SetStreamBuffers(size_t bufferSize,
  36                                                                                 int32 bufferCount)
  37 {
  38         UNIMPLEMENTED();
  39
  40         return B_ERROR;
  41 }
  42
  43
  44 status_t
  45 BAbstractBufferStream::StartStreaming()
  46 {
  47         UNIMPLEMENTED();
  48
  49         return B_ERROR;
  50 }
  51
  52
  53 status_t
  54 BAbstractBufferStream::StopStreaming()
  55 {
  56         UNIMPLEMENTED();
  57
  58         return B_ERROR;
  59 }
  60
  61 /*************************************************************
  62  * protected BAbstractBufferStream
  63  *************************************************************/
  64
  65 void
  66 BAbstractBufferStream::_ReservedAbstractBufferStream1()
  67 {
  68         UNIMPLEMENTED();
  69 }
  70
  71
  72 void
  73 BAbstractBufferStream::_ReservedAbstractBufferStream2()
  74 {
  75         UNIMPLEMENTED();
  76 }
  77
  78
  79 void
  80 BAbstractBufferStream::_ReservedAbstractBufferStream3()
  81 {
  82         UNIMPLEMENTED();
  83 }
  84
  85
  86 void
  87 BAbstractBufferStream::_ReservedAbstractBufferStream4()
  88 {
  89         UNIMPLEMENTED();
  90 }
  91
  92
  93 stream_id
  94 BAbstractBufferStream::StreamID() const
  95 {
  96         UNIMPLEMENTED();
  97
  98         return 0;
  99 }
 100
 101
 102 status_t
 103 BAbstractBufferStream::Subscribe(char *name,
 104                                                                  subscriber_id *subID,
 105                                                                  sem_id semID)
 106 {
 107         UNIMPLEMENTED();
 108
 109         return B_ERROR;
 110 }
 111
 112
 113 status_t
 114 BAbstractBufferStream::Unsubscribe(subscriber_id subID)
 115 {
 116         UNIMPLEMENTED();
 117
 118         return B_ERROR;
 119 }
 120
 121
 122 status_t
 123 BAbstractBufferStream::EnterStream(subscriber_id subID,
 124                                                                    subscriber_id neighbor,
 125                                                                    bool before)
 126 {
 127         UNIMPLEMENTED();
 128
 129         return B_ERROR;
 130 }
 131
 132
 133 status_t
 134 BAbstractBufferStream::ExitStream(subscriber_id subID)
 135 {
 136         UNIMPLEMENTED();
 137
 138         return B_ERROR;
 139 }
 140
 141
 142 BMessenger *
 143 BAbstractBufferStream::Server() const
 144 {
 145         UNIMPLEMENTED();
 146         return NULL;
 147 }
 148
 149
 150 status_t
 151 BAbstractBufferStream::SendRPC(BMessage *msg,
 152                                                            BMessage *reply) const
 153 {
 154         UNIMPLEMENTED();
 155
 156         return B_ERROR;
 157 }
 158
 159 /*************************************************************
 160  * public BBufferStream
 161  *************************************************************/
 162
 163 BBufferStream::BBufferStream(size_t headerSize,
 164                                                          BBufferStreamManager *controller,
 165                                                          BSubscriber *headFeeder,
 166                                                          BSubscriber *tailFeeder)
 167 {
 168         UNIMPLEMENTED();
 169 }
 170
 171
 172 BBufferStream::~BBufferStream()
 173 {
 174         UNIMPLEMENTED();
 175 }
 176
 177
 178 void *
 179 BBufferStream::operator new(size_t size)
 180 {
 181         UNIMPLEMENTED();
 182
 183         void *dummy = NULL;
 184                 // just to circumvent a warning that operator new should not return NULL
 185         return dummy;
 186 }
 187
 188
 189 void
 190 BBufferStream::operator delete(void *stream, size_t size)
 191 {
 192         UNIMPLEMENTED();
 193 }
 194
 195
 196 size_t
 197 BBufferStream::HeaderSize() const
 198 {
 199         UNIMPLEMENTED();
 200
 201         return 0;
 202 }
 203
 204
 205 status_t
 206 BBufferStream::GetStreamParameters(size_t *bufferSize,
 207                                                                    int32 *bufferCount,
 208                                                                    bool *isRunning,
 209                                                                    int32 *subscriberCount) const
 210 {
 211         UNIMPLEMENTED();
 212
 213         return B_ERROR;
 214 }
 215
 216
 217 status_t
 218 BBufferStream::SetStreamBuffers(size_t bufferSize,
 219                                                                 int32 bufferCount)
 220 {
 221         UNIMPLEMENTED();
 222
 223         return B_ERROR;
 224 }
 225
 226
 227 status_t
 228 BBufferStream::StartStreaming()
 229 {
 230         UNIMPLEMENTED();
 231
 232         return B_ERROR;
 233 }
 234
 235
 236 status_t
 237 BBufferStream::StopStreaming()
 238 {
 239         UNIMPLEMENTED();
 240
 241         return B_ERROR;
 242 }
 243
 244
 245 BBufferStreamManager *
 246 BBufferStream::StreamManager() const
 247 {
 248         UNIMPLEMENTED();
 249         return NULL;
 250 }
 251
 252
 253 int32
 254 BBufferStream::CountBuffers() const
 255 {
 256         UNIMPLEMENTED();
 257
 258         return 0;
 259 }
 260
 261
 262 status_t
 263 BBufferStream::Subscribe(char *name,
 264                                                  subscriber_id *subID,
 265                                                  sem_id semID)
 266 {
 267         UNIMPLEMENTED();
 268
 269         return B_ERROR;
 270 }
 271
 272
 273 status_t
 274 BBufferStream::Unsubscribe(subscriber_id subID)
 275 {
 276         UNIMPLEMENTED();
 277
 278         return B_ERROR;
 279 }
 280
 281
 282 status_t
 283 BBufferStream::EnterStream(subscriber_id subID,
 284                                                    subscriber_id neighbor,
 285                                                    bool before)
 286 {
 287         UNIMPLEMENTED();
 288
 289         return B_ERROR;
 290 }
 291
 292
 293 status_t
 294 BBufferStream::ExitStream(subscriber_id subID)
 295 {
 296         UNIMPLEMENTED();
 297
 298         return B_ERROR;
 299 }
 300
 301
 302 bool
 303 BBufferStream::IsSubscribed(subscriber_id subID)
 304 {
 305         UNIMPLEMENTED();
 306
 307         return false;
 308 }
 309
 310
 311 bool
 312 BBufferStream::IsEntered(subscriber_id subID)
 313 {
 314         UNIMPLEMENTED();
 315
 316         return false;
 317 }
 318
 319
 320 status_t
 321 BBufferStream::SubscriberInfo(subscriber_id subID,
 322                                                           char **name,
 323                                                           stream_id *streamID,
 324                                                           int32 *position)
 325 {
 326         UNIMPLEMENTED();
 327
 328         return B_ERROR;
 329 }
 330
 331
 332 status_t
 333 BBufferStream::UnblockSubscriber(subscriber_id subID)
 334 {
 335         UNIMPLEMENTED();
 336
 337         return B_ERROR;
 338 }
 339
 340
 341 status_t
 342 BBufferStream::AcquireBuffer(subscriber_id subID,
 343                                                          buffer_id *bufID,
 344                                                          bigtime_t timeout)
 345 {
 346         UNIMPLEMENTED();
 347
 348         return B_ERROR;
 349 }
 350
 351
 352 status_t
 353 BBufferStream::ReleaseBuffer(subscriber_id subID)
 354 {
 355         UNIMPLEMENTED();
 356
 357         return B_ERROR;
 358 }
 359
 360
 361 size_t
 362 BBufferStream::BufferSize(buffer_id bufID) const
 363 {
 364         UNIMPLEMENTED();
 365
 366         return 0;
 367 }
 368
 369
 370 char *
 371 BBufferStream::BufferData(buffer_id bufID) const
 372 {
 373         UNIMPLEMENTED();
 374         return NULL;
 375 }
 376
 377
 378 bool
 379 BBufferStream::IsFinalBuffer(buffer_id bufID) const
 380 {
 381         UNIMPLEMENTED();
 382
 383         return false;
 384 }
 385
 386
 387 int32
 388 BBufferStream::CountBuffersHeld(subscriber_id subID)
 389 {
 390         UNIMPLEMENTED();
 391
 392         return 0;
 393 }
 394
 395
 396 int32
 397 BBufferStream::CountSubscribers() const
 398 {
 399         UNIMPLEMENTED();
 400
 401         return 0;
 402 }
 403
 404
 405 int32
 406 BBufferStream::CountEnteredSubscribers() const
 407 {
 408         UNIMPLEMENTED();
 409
 410         return 0;
 411 }
 412
 413
 414 subscriber_id
 415 BBufferStream::FirstSubscriber() const
 416 {
 417         UNIMPLEMENTED();
 418
 419         return 0;
 420 }
 421
 422
 423 subscriber_id
 424 BBufferStream::LastSubscriber() const
 425 {
 426         UNIMPLEMENTED();
 427
 428         return 0;
 429 }
 430
 431
 432 subscriber_id
 433 BBufferStream::NextSubscriber(subscriber_id subID)
 434 {
 435         UNIMPLEMENTED();
 436
 437         return 0;
 438 }
 439
 440
 441 subscriber_id
 442 BBufferStream::PrevSubscriber(subscriber_id subID)
 443 {
 444         UNIMPLEMENTED();
 445
 446         return 0;
 447 }
 448
 449
 450 void
 451 BBufferStream::PrintStream()
 452 {
 453         UNIMPLEMENTED();
 454 }
 455
 456
 457 void
 458 BBufferStream::PrintBuffers()
 459 {
 460         UNIMPLEMENTED();
 461 }
 462
 463
 464 void
 465 BBufferStream::PrintSubscribers()
 466 {
 467         UNIMPLEMENTED();
 468 }
 469
 470
 471 bool
 472 BBufferStream::Lock()
 473 {
 474         UNIMPLEMENTED();
 475
 476         return false;
 477 }
 478
 479
 480 void
 481 BBufferStream::Unlock()
 482 {
 483         UNIMPLEMENTED();
 484 }
 485
 486
 487 status_t
 488 BBufferStream::AddBuffer(buffer_id bufID)
 489 {
 490         UNIMPLEMENTED();
 491
 492         return B_ERROR;
 493 }
 494
 495
 496 buffer_id
 497 BBufferStream::RemoveBuffer(bool force)
 498 {
 499         UNIMPLEMENTED();
 500
 501         return 0;
 502 }
 503
 504
 505 buffer_id
 506 BBufferStream::CreateBuffer(size_t size,
 507                                                         bool isFinal)
 508 {
 509         UNIMPLEMENTED();
 510
 511         return 0;
 512 }
 513
 514
 515 void
 516 BBufferStream::DestroyBuffer(buffer_id bufID)
 517 {
 518         UNIMPLEMENTED();
 519 }
 520
 521
 522 void
 523 BBufferStream::RescindBuffers()
 524 {
 525         UNIMPLEMENTED();
 526 }
 527
 528 /*************************************************************
 529  * private BBufferStream
 530  *************************************************************/
 531
 532 void
 533 BBufferStream::_ReservedBufferStream1()
 534 {
 535         UNIMPLEMENTED();
 536 }
 537
 538
 539 void
 540 BBufferStream::_ReservedBufferStream2()
 541 {
 542         UNIMPLEMENTED();
 543 }
 544
 545
 546 void
 547 BBufferStream::_ReservedBufferStream3()
 548 {
 549         UNIMPLEMENTED();
 550 }
 551
 552
 553 void
 554 BBufferStream::_ReservedBufferStream4()
 555 {
 556         UNIMPLEMENTED();
 557 }
 558
 559
 560 void
 561 BBufferStream::InitSubscribers()
 562 {
 563         UNIMPLEMENTED();
 564 }
 565
 566
 567 bool
 568 BBufferStream::IsSubscribedSafe(subscriber_id subID) const
 569 {
 570         UNIMPLEMENTED();
 571
 572         return false;
 573 }
 574
 575
 576 bool
 577 BBufferStream::IsEnteredSafe(subscriber_id subID) const
 578 {
 579         UNIMPLEMENTED();
 580
 581         return false;
 582 }
 583
 584
 585 void
 586 BBufferStream::InitBuffers()
 587 {
 588         UNIMPLEMENTED();
 589 }
 590
 591
 592 status_t
 593 BBufferStream::WakeSubscriber(subscriber_id subID)
 594 {
 595         UNIMPLEMENTED();
 596
 597         return B_ERROR;
 598 }
 599
 600
 601 void
 602 BBufferStream::InheritBuffers(subscriber_id subID)
 603 {
 604         UNIMPLEMENTED();
 605 }
 606
 607
 608 void
 609 BBufferStream::BequeathBuffers(subscriber_id subID)
 610 {
 611         UNIMPLEMENTED();
 612 }
 613
 614
 615 status_t
 616 BBufferStream::ReleaseBufferSafe(subscriber_id subID)
 617 {
 618         UNIMPLEMENTED();
 619
 620         return B_ERROR;
 621 }
 622
 623
 624 status_t
 625 BBufferStream::ReleaseBufferTo(buffer_id bufID,
 626                                                            subscriber_id subID)
 627 {
 628         UNIMPLEMENTED();
 629
 630         return B_ERROR;
 631 }
 632
 633
 634 void
 635 BBufferStream::FreeAllBuffers()
 636 {
 637         UNIMPLEMENTED();
 638 }
 639
 640
 641 void
 642 BBufferStream::FreeAllSubscribers()
 643 {
 644         UNIMPLEMENTED();
 645 }
 646
 647
 648 #endif  // __GNUC__ < 3
 649