signalsequence_impl.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   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                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef SIGNALSEQUENCE_IMPL_H
#define SIGNALSEQUENCE_IMPL_H


#include <iostream>
#include <sstream>
#include <complex>
#include <vector>
#include <stdexcept>
#include <typeinfo>

#include <simthetic/signals.h>
#include <simthetic/phbib.h>

namespace simth
{

template<class Val, class Attr, class Cont, class Stor, class Accs>
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::SignalSequenceBase(iterator iterStart,
    iterator iterEnd, storage_type &seq)
    : storage(&seq)
    , iter1(iterStart)
    , iter2(iterEnd)
    , size_( std::distance(iter1,iter2) ), capacity_(size_)
{
  invariante();
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::SignalSequenceBase(storage_type &seq)
    : storage(&seq), iter1(seq.begin()), iter2(seq.end()),
    size_( std::distance(iter1,iter2) ), capacity_(size_)
{
  invariante();
}

/* Constructor that can be used only by derived classes.
   A derived class must call seek(iter1,iter1,stor) after using
  this constructor!
*/
template<class Val, class Attr, class Cont, class Stor, class Accs>
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::SignalSequenceBase( )
    : storage(NULL)
{
  //invariante(); is not fulfilled here!
  //call seek(iter1,iter1,stor)  after using this constructor!
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::~SignalSequenceBase()
{
  // nothing to delete here.
}


template<class Val, class Attr, class Cont, class Stor, class Accs>
inline void SignalSequenceBase<Val, Attr, Cont, Stor, Accs>::invariante() const
{
#if DEBUG==1
  if(std::distance(iter1,iter2) != int(size())) {
    throw std::logic_error("void SignalSequenceBase<T,Sto>::invariante: "
                           "distance(iter1,iter2)=="
                           +simth::i2string(std::distance(iter1,iter2))
                           +" != size()=="+simth::i2string(size()));
  }
  if(capacity() < size()) {
    throw std::runtime_error("void SignalSequenceBase<T,Sto>::invariante: "
                             "capacity < size");
  }
#endif
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
SignalSequenceBase<Val, Attr, Cont, Stor, Accs>&
SignalSequenceBase<Val, Attr, Cont, Stor, Accs>::operator=(const SignalSequenceBase<value_type,attributes_type,container_type,storage_type,access_type>& seq)
{
  if(&seq == this) {
    return *this;
  }

  resize( seq.size() );

  iterator thisIter = begin();
  for(const_iterator fromIter = seq.begin(); fromIter!=seq.end(); ++fromIter) {
    (*thisIter) = (*fromIter);
    ++thisIter;
  }

  if(&(rAttributes()) != &(seq.rAttributes()) &&
      rAttributes() != seq.rAttributes()) {
    wAttributes() = seq.rAttributes();
  }

  invariante();
  return *this;
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
void SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::resize(size_t newSize)
{

  if(newSize == size()) {
    return;
  }

  if(newSize > capacity()) {
    std::ostringstream ost;
    ost<<"void SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::resize(size_t newSize) : Resizing to a size larger ";
    ost<<"than the capacity is not possible for a shallow copy sequence. Old size: "<<size()<<", capacity: "<<capacity();
    ost<<" new size: "<<newSize;
    throw std::runtime_error(ost.str());
  }

  iter2 = iter1+ newSize;
  size_ = newSize;

  invariante();
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
void SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::seek(iterator newStart, iterator newEnd)
{
  iter1 = newStart;
  iter2 = newEnd;
  size_ = std::distance(iter1,iter2);
  capacity_  = size_;
  invariante();
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
void SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::seek(iterator newStart, iterator newEnd,storage_type& storage_)
{
  iter1 = newStart;
  iter2 = newEnd;
  storage = &storage_;
  size_ = std::distance(iter1,iter2);
  capacity_  = size_;
  invariante();
}


template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::iterator
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::begin()
{
  invariante();
  return iter1;
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::const_iterator
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::begin() const
{
  invariante();
  return iter1;
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::iterator
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::end()
{
  invariante();
  return iter2;
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::const_iterator
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::end() const
{
  invariante();
  return iter2;
}




/* ****************************************************+
    SignalSequence  (derived from SignalSequenceBase)
 
 */


template<class Val, class Attr, class Cont>
SignalSequence<Val,Attr,Cont>::SignalSequence(iterator iterStart,iterator iterEnd, storage_type &seq)
    :   SignalSequenceBase<Val,Attr,Cont,storage_type,access_type>(iterStart,iterEnd,seq)
{ }

template<class Val, class Attr, class Cont>
SignalSequence<Val,Attr,Cont>::SignalSequence(storage_type &seq)
    : SignalSequenceBase<Val,Attr,Cont,storage_type,access_type>(seq)
{ }

/* Constructor that can be used only by derived classes.
   A derived class must call seek(iter1,iter1,stor) after using
  this constructor!
*/
template<class Val, class Attr, class Cont>
SignalSequence<Val,Attr,Cont>::SignalSequence( )
    : SignalSequenceBase<Val,Attr,Cont,storage_type,access_type>( )
{ //invariante(); is not fulfilled here!
  //call seek(iter1,iter1,stor)  after using this constructor!
}

template<class Val, class Attr, class Cont>
SignalSequence<Val,Attr,Cont>::~SignalSequence()
{
  // nothing to delete here.
}





/* ****************************************************+
    Storage class
 
*/


template<class T, class A, class Cont>
SignalSequenceStorage<T,A,Cont>::SignalSequenceStorage()
    : base_type( ),ownStorage(0), attributes_(), lock_(false)
{
  seek(ownStorage.begin(),ownStorage.end(),*this);
  invariante();
}

template<class T, class A, class Cont>
SignalSequenceStorage<T,A,Cont>::SignalSequenceStorage(size_t size, const value_type &val)
    : base_type( ),ownStorage(size,val), attributes_(), lock_(false)
{
  seek(ownStorage.begin(),ownStorage.end(),*this);
  invariante();
}

template<class T, class A, class Cont>
SignalSequenceStorage<T,A,Cont>::SignalSequenceStorage(const SignalSequence<value_type,attributes_type,container_type> &seq)
    : base_type( ), ownStorage(seq.size()), attributes_( seq.rAttributes() ), lock_(false)
{
  seek(ownStorage.begin(),ownStorage.end(),*this);
  invariante();

  if(DEBUG) {
    if(base_type::size() != seq.size()) {
      throw std::logic_error("SignalSequenceStorage<T,A,Cont>::SignalSequenceStorage(..) : error 1a");
    }
  }
  iterator to = ownStorage.begin();
  for(const_iterator from = seq.begin();from!=seq.end();++from) {
    *to = *from;
    ++to;
  }
  invariante();
}

template<class T, class A, class Cont>
SignalSequenceStorage<T,A,Cont>::~SignalSequenceStorage()
{ }

template<class T, class A, class Cont>
inline void SignalSequenceStorage<T,A,Cont>::invariante() const
{
#if DEBUG==1
  if(base_type::begin() != ownStorage.begin() || 
     base_type::end() != ownStorage.end()) {
    throw std::logic_error("inline void SignalSequenceStorage<T,A,Cont>::invariante() const : error 1");
  }
#endif
}

template<class T, class A, class Cont>
A& SignalSequenceStorage<T,A,Cont>::wAttributes()
{
  //#if SECURITY==1
  if(base_type::isAttributesLocked()) {
    //assert(0);
    throw std::runtime_error("SignalSequenceStorage::wAttributes(): "
                             "write access to attributes requested "
                             "while attributes are locked, in class "
                             + std::string(typeid(*this).name()));
  }
  //#endif
  return attributes_ ;
}

template<class T, class A, class Cont>
void SignalSequenceStorage<T,A,Cont>::resize(size_t newSize)
{
  // Note: if this resizes to something bigger than capacity(), the
  // memory allocation probably will change. All existing iterators
  // and other shallow copies will then point to garbage.
  ownStorage.resize(newSize);
  // Set the iterators to the new begin and end.
  seek(ownStorage.begin(),ownStorage.end());
  invariante();
}


}

#endif // SIGNALSEQUENCE_IMPL_H

---