linked_buffer.cpp

Go to the documentation of this file.

#ifndef LINKED_BUFFER_IMPLEMENTATION_FILE
#define LINKED_BUFFER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : linked_buffer                                                     *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "buffer.h"
#include "buffer_key.h"
#include "linked_buffer.h"

#include <basis/byte_array.h>
#include <basis/function.h>
#include <basis/mutex.h>
#include <data_struct/bit_vector.h>
#include <data_struct/span_manager.h>
#include <mechanisms/time_stamp.h>

linked_buffer::linked_buffer(const buffer_key &key, buffer *real_buffer)
: _the_key(new buffer_key(key)),
  _the_buffer(real_buffer),
  _lock(new mutex)
{
  _the_buffer->add_reference(key.connection);
}

linked_buffer::~linked_buffer()
{
  _the_buffer->remove_reference(_the_key->connection);
  if (!_the_buffer->references()) {
    // wow, we are the lucky winner that gets to clean up.
    WHACK(_the_buffer);
  }
  _the_buffer = NIL;
  WHACK(_the_key);
  WHACK(_lock);
}

// this should be safe since we don't allow the buffer that's linked to be
// changed during lifetime of linked_buffer object.
buffer &linked_buffer::access_buffer() { return *_the_buffer; }

buffer_key linked_buffer::key() const
{
  auto_synchronizer l(*_lock);
  return *_the_key;
}

void linked_buffer::set_key(const buffer_key &to_set)
{
  auto_synchronizer l(*_lock);
  *_the_key = to_set;
}

istring linked_buffer::text_form() const
{
  auto_synchronizer l(*_lock);
  return istring(istring::SPRINTF, "[%d] size=%d alive=%s conn_id=%d "
      "msg_id=%d whole?=%s mod_time=%s", _the_key->buff_id.raw_id(),
      (whole()? full_length() : (estimate()? estimate() : -1) ),
      (alive()? "true" : "false"), _the_key->connection, _the_key->msg_id,
      (whole()? "true":"false"),
      _the_buffer->last_add().text_form().observe());
  // note that -1 is used here as a kludgy way of saying "has not been
  // determined yet".
}

istring linked_buffer::detailed_form(bool really_detailed) const
{
  auto_synchronizer l(*_lock);
  istring to_return(text_form() + istring(" "));
  span_manager buff_status = _the_buffer->buffer_status();
  int_array pack_sizes = _the_buffer->packet_sizes();
  to_return += buff_status.print_received_list();
  if (really_detailed) {
    to_return += " lengths: ";
    for (int i = 0; i < packets(); i++) {
      if (buff_status.vector().on(i))
        to_return += istring(istring::SPRINTF, "[%d=%d] ", i, pack_sizes[i]);
      else to_return += istring(istring::SPRINTF, "[%d=empty] ", i);
    }
  }
  return to_return;
}

// re-routing bank.
bool linked_buffer::alive() const { return _the_buffer->alive(); }
int linked_buffer::packets() const  { return _the_buffer->packets(); }
outcome linked_buffer::store_packet(int packet_number, const byte_array &buffer)
{ return _the_buffer->store_packet(packet_number, buffer); }
byte_array linked_buffer::get_packet(int packet_number) const
{ return _the_buffer->get_packet(packet_number); }
int linked_buffer::packet_length(int packet_number) const
{ return _the_buffer->packet_length(packet_number); }
bool linked_buffer::whole() const { return _the_buffer->whole(); }
bool linked_buffer::empty() const { return _the_buffer->empty(); }
int linked_buffer::full_length(int offset) const
{ return _the_buffer->full_length(offset); }
int linked_buffer::guess_size(int offset)
{ return _the_buffer->guess_size(offset); }
bool linked_buffer::did_estimate() const
{ return _the_buffer->did_estimate(); }
void linked_buffer::reset_estimate() { _the_buffer->reset_estimate(); }
int linked_buffer::estimate() const { return _the_buffer->estimate(); }
outcome linked_buffer::dump(byte_array &storage_location, int offset)
{ return _the_buffer->dump(storage_location, offset); }
void linked_buffer::release(int packet_number, release_style status_handling)
{ _the_buffer->release(packet_number, status_handling); }
void linked_buffer::release() { _the_buffer->release(); }
time_stamp linked_buffer::last_add() const { return _the_buffer->last_add(); }
void linked_buffer::set_last_add(const time_stamp &new_last_add)
{ _the_buffer->set_last_add(new_last_add); }
bool linked_buffer::owner_alerted() const
{ return _the_buffer->owner_alerted(); }
void linked_buffer::set_alerted(bool owner_alerted)
{ _the_buffer->set_alerted(owner_alerted); }
void linked_buffer::get_attachment(byte_array &storage) const
{ _the_buffer->get_attachment(storage); }
void linked_buffer::set_attachment(const byte_array &new_attachment)
{ _the_buffer->set_attachment(new_attachment); }
span_manager linked_buffer::buffer_status() const
{ return _the_buffer->buffer_status(); }
int_array linked_buffer::packet_sizes() const
{ return _the_buffer->packet_sizes(); }


#endif //LINKED_BUFFER_IMPLEMENTATION_FILE

---