S3FC project page

S3FC home page

---

               

---

s3_inplace_fifo_mux.tcc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_inplace_fifo_mux.h>
#include <s3fc/s3_exception.h>
#include <s3fc/s3_macros.h>
#include <algorithm>

//
template<typename T>
s3_inplace_fifo_mux<T>::stub_queue::stub_queue(
   s3_inplace_fifo_mux<T>* n_mux) :
   mux(n_mux)
{
}

//
template<typename T>
bool s3_inplace_fifo_mux<T>::stub_queue::empty()  const
{
   // lock, wait, forward, unlock
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) lock_select();
   bool ef = mux->queue->empty();
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) unlock_next();
   return ef;
}

//
template<typename T>
bool s3_inplace_fifo_mux<T>::stub_queue::full() const
{
   // lock, wait, forward, unlock
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) lock_select();
   bool ff = mux->queue->full();
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) unlock_next();
   return ff;
}
// CONST_OVERRIDE_THIS(x) const_cast<x*>(this)->

//
template<typename T>
unsigned int s3_inplace_fifo_mux<T>::stub_queue::size() const
{
   // lock, wait, forward, unlock
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) lock_select();
   unsigned int s = mux->queue->size();
   CONST_OVERRIDE_THIS(s3_inplace_fifo_mux<T>::stub_queue) unlock_next();
   return s;
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stub_queue::push(const T& t) 
{
   // lock, wait, forward, unlock
   lock_select();
   mux->queue->push(t);
   unlock_next();
}

//
template<typename T>
T s3_inplace_fifo_mux<T>::stub_queue::pop()
{
   T t;
   // lock, wait, forward, unlock
   lock_select();
   t = mux->queue->pop();
   unlock_next();
   return t;
}

//
template<typename T>
T* s3_inplace_fifo_mux<T>::stub_queue::open_input()
{
   T* t;
   // lock, wait, forward, unlock
   lock_select();
   t = mux->queue->open_input();
   unlock_next();
   return t;
}

//
template<typename T>
T* s3_inplace_fifo_mux<T>::stub_queue::nbl_open_input()
{
   T* t;
   // lock, wait, forward, unlock
   lock_select();
   t = mux->queue->nbl_open_input();
   unlock_next();
   return t;
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stub_queue::close_input(const T* t)
{
   // forward
   mux->queue->close_input(t);
}

//
template<typename T>
T* s3_inplace_fifo_mux<T>::stub_queue::open_output()
{
   T* t;
   // lock, wait, forward, unlock
   lock_select();
   t = mux->queue->open_output();
   unlock_next();
   return t;
}

//
template<typename T>
T* s3_inplace_fifo_mux<T>::stub_queue::nbl_open_output()
{
   T* t;
   // lock, wait, forward, unlock
   lock_select();
   t = mux->queue->nbl_open_output();
   unlock_next();
   return t;
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stub_queue::close_output(const T* t)
{
   // forward
   mux->queue->close_output(t);
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stub_queue::lock_select()
{
   mux->state_lock.lock();
   // am I NOT currently selected ?
   if ( mux->vqueue_list[mux->current_idx] != this )
   {
      // unlock lock and wait until I get selected
      waiter.wait(mux->state_lock);
   }
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stub_queue::unlock_next()
{
   // auto-select enabled ?
   if ( mux->auto_select )
   {
      // advance to next queue in list
      mux->current_idx = (mux->current_idx + 1) % (mux->vqueue_list.size());
      // notify newly selected queue
      mux->vqueue_list[mux->current_idx]->waiter.broadcast();
   }
   mux->state_lock.unlock();
}

//
template<typename T>
s3_inplace_fifo_mux<T>::s3_inplace_fifo_mux() :
   queue(0),
   vqueue_list(0),
   current_idx(0),
   started(false),
   auto_select(true)
{
}

//
template<typename T>
s3_inplace_fifo_mux<T>::~s3_inplace_fifo_mux()
{
   for (typename std::vector<stub_queue*>::iterator ptr = vqueue_list.begin();
   ptr != vqueue_list.end();
   ptr++) 
   {
      delete *ptr;
   }
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::start()
{
   state_lock.lock();
   if ( started == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::start()",
    "already started");
   }
   started = true;
   state_lock.unlock();
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::stop()
{
   state_lock.lock();
   if ( started == false )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::stop()",
    "already stopped");
   }
   started = false;
   state_lock.unlock();
}

//
template<typename T>
bool s3_inplace_fifo_mux<T>::is_started() const
{
   bool s;
   state_lock.lock();
   s = started;
   state_lock.unlock();
   return s;
}

//
template<typename T>
s3_inplace_fifo_base<T>& s3_inplace_fifo_mux<T>::create_vqueue()
{
   state_lock.lock();
   if ( started == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::create_vqueue()",
    "attempt to create_vqueue on started mux");
   }
   s3_inplace_fifo_mux<T>::stub_queue* q = new stub_queue(this);
   vqueue_list.push_back(q);
   state_lock.unlock();
   return *q;
}

//
template<typename T>
void s3_inplace_fifo_mux<T>::destroy_vqueue(const s3_inplace_fifo_base<T>& q)
{
   state_lock.lock();
   if ( started == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::destroy_vqueue()",
    "attempt to invoke on started mux");
   }
#if 0
   // dynamic cast down and check
   const stub_queue<T>* qp = dynamic_cast<const stub_queue<T>*>(&q);
   if ( qp == 0 )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::destroy_vqueue()",
    "q is not an s3_inplace_fifo_mux<T>::stub_queue instance.");
   }
#else
   const s3_inplace_fifo_mux<T>::stub_queue* qp =
      reinterpret_cast<const s3_inplace_fifo_mux<T>::stub_queue*>(&q);
#endif
   typename std::vector<s3_inplace_fifo_mux<T>::stub_queue*>::iterator iter =
      std::find(vqueue_list.begin(), vqueue_list.end(), qp);
   if ( iter == vqueue_list.end() )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::destroy_vqueue()",
    "virtual queue list does not contain specified entry.");
   }
   vqueue_list.erase(iter);
   state_lock.unlock();
}

#if 0
//
template<typename T>
void s3_inplace_fifo_mux<T>::select_vqueue(const s3_inplace_fifo_base<T>& vq)
{
   state_lock.lock();
   // check state
   if ( started == true && auto_select == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::select_vqueue()",
    "attempt to invoke on started auto-selecting mux");
   }
   // dynamic cast down and check
   const s3_inplace_fifo_mux<T>::stub_queue* qp =
      dynamic_cast<const s3_inplace_fifo_mux<T>::stub_queue*>(&vq);
   if ( qp == 0 )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::select_vqueue()",
    "q is not an s3_inplace_fifo_mux<T>::stub_queue instance.");
   }
   typename vector<stub_queue<T>*>::iterator iter = find(
      vqueue_list.begin(), vqueue_list.end(), qp);
   if ( iter == vqueue_list.end() )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::select_vqueue()",
    "virtual queue list does not contain specified entry.");
   }
   current_idx = iter - vqueue_list.begin();
   state_lock.unlock();
}
#endif

//
template<typename T>
void s3_inplace_fifo_mux<T>::set_queue(s3_inplace_fifo_base<T>& q)
{
   state_lock.lock();
   if ( started == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::set_queue()",
    "attempt to invoke on started auto-selecting mux");
   }
   queue = &q;
   state_lock.unlock();
}

#if 0
//
template<typename T>
void s3_inplace_fifo_mux<T>::set_auto_select(bool n_val)
{
   state_lock.lock();
   if ( started == true )
   {
      state_lock.unlock();
      throw s3_generic_exception(
    "s3_inplace_fifo_mux<T>::set_queue()",
    "attempt to invoke on started auto-selecting mux");
   }
   auto_select = n_val;
   state_lock.unlock();
}
#endif

---

Send comments to: s3fc@stonethree.com