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 <MediaDebug.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 650