ring_buffer.h

Go to the documentation of this file.

/*
 *  ring_buffer.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST 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.
 *
 *  NEST 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef RING_BUFFER_H
#define RING_BUFFER_H
#include <valarray>
#include <list>
#include "nest.h"
#include "scheduler.h"
#include "nest_time.h"

namespace nest
{

  class RingBuffer {
  public:
    
    RingBuffer();
    
    void add_value(const long_t offs, const double_t);

    void set_value(const long_t offs, const double_t);

    double get_value(const long_t offs);
    
    void clear();

    void resize();

    size_t size() const { return buffer_.size(); }

  private:        

    std::valarray<double_t> buffer_;

    size_t get_index_(const delay d) const;

  };
  
  inline
  void RingBuffer::add_value(const long_t offs, const double_t v)
  {
    buffer_[get_index_(offs)] += v;
  }

  inline
  void RingBuffer::set_value(const long_t offs, const double_t v)
  {
    buffer_[get_index_(offs)] = v;
  }

  inline
  double RingBuffer::get_value(const long_t offs)
  {
    assert(0 <= offs && (size_t)offs < buffer_.size());
    assert((delay)offs < Scheduler::get_min_delay());

    // offs == 0 is beginning of slice, but we have to
    // take modulo into account when indexing
    long_t   idx = get_index_(offs);
    double_t val = buffer_[idx]; 
    buffer_[idx] = 0.0;   // clear buffer after reading
    return val;
  }

  inline 
  size_t RingBuffer::get_index_(const delay d) const
  {
    const long_t idx = Scheduler::get_modulo(d);
    assert(0 <= idx);
    assert((size_t)idx < buffer_.size());
    return idx;
  }




  class MultRBuffer {
  public:
    
    MultRBuffer();
    
    void add_value(const long_t offs, const double_t);

    double get_value(const long_t offs);
    
    void clear();

    void resize();

    size_t size() const { return buffer_.size(); }

  private:        

    std::valarray<double_t> buffer_;

    size_t get_index_(const delay d) const;

  };
  
  inline
  void MultRBuffer::add_value(const long_t offs, const double_t v)
  {
    assert(0<= offs && (size_t)offs < buffer_.size());
    buffer_[get_index_(offs)] *= v;
  }

  inline
  double MultRBuffer::get_value(const long_t offs)
  {
    assert(0 <= offs && (size_t)offs < buffer_.size());
    assert((delay)offs < Scheduler::get_min_delay());

    // offs == 0 is beginning of slice, but we have to
    // take modulo into account when indexing
    long_t   idx = get_index_(offs);
    double_t val = buffer_[idx]; 
    buffer_[idx] = 0.0;   // clear buffer after reading
    return val;
  }

  inline 
  size_t MultRBuffer::get_index_(const delay d) const
  {
    const long_t idx = Scheduler::get_modulo(d);
    assert(0 <= idx && (size_t)idx < buffer_.size());
    return idx;
  }
 


  class ListRingBuffer {
  public:
    
    ListRingBuffer();
    
    void append_value(const long_t offs, const double_t);

    std::list<double_t>& get_list(const long_t offs);
    
    void clear();

    void resize();

    size_t size() const { return buffer_.size(); }

  private:        

    std::vector<std::list<double_t> > buffer_;

    size_t get_index_(const delay d) const;

  };
  
  inline
  void ListRingBuffer::append_value(const long_t offs, const double_t v)
  {
    buffer_[get_index_(offs)].push_back(v);
  }

  inline
  std::list<double_t>& ListRingBuffer::get_list(const long_t offs)
  {
    assert(0 <= offs && (size_t)offs < buffer_.size());
    assert((delay)offs < Scheduler::get_min_delay());

    // offs == 0 is beginning of slice, but we have to
    // take modulo into account when indexing
    long_t   idx = get_index_(offs);
    return buffer_[idx]; 
  }

  inline 
  size_t ListRingBuffer::get_index_(const delay d) const
  {
    const long_t idx = Scheduler::get_modulo(d);
    assert(0 <= idx);
    assert((size_t)idx < buffer_.size());
    return idx;
  }

}


#endif