matrixseq.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 MATRIXSEQ_H
#define MATRIXSEQ_H

//#include <valarray>
#include <vector>
#include <cstddef>
#include <exception>

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

#include "matrix.h"

namespace mimo {

/* Template matrix sequence class. Don't use this directly, only use
 * the typedefs below. */
template<class elemT, class Attr, 
     class Cont = std::vector<elemT> > class MSequence;
template<class elemT, class Attr, class Cont> class MSequenceStorage;
template<class elemT, class Attr, class Cont> class MSequenceAccess;

/* Template attributes class, which is internally used for the
 * matrix/vector sequences to store the matrix/vector
 * dimensions. Don't use this outside of the sequence classes. */
template<class elemT> class MSeqAttrT;
template<class elemT> class VSeqAttrT;
template<class elemT> class MFreqSeqAttrT;
template<class elemT> class VTimeSeqAttrT;
template<class elemT> class MTimeSeqAttrT;
//typedef MSeqAttrT<CMatrix> MSeqAttr;
//typedef VSeqAttrT<CVector> VSeqAttr;

typedef MSequence<CMatrix, MSeqAttrT<CMatrix> > CMatrixSeq;

typedef MSequence<CMatrix, MFreqSeqAttrT<CMatrix> > MatrixFreqSignal;

typedef MSequence<CVector, VSeqAttrT<CVector> > CVectorSeq;

typedef MSequence<CVector, VTimeSeqAttrT<CVector> > VectorTimeSignal;

typedef MSequence<CMatrix, MTimeSeqAttrT<CMatrix> > MatrixTimeSignal;

//typedef MSequence<Matrix, MSeqAttrT<Matrix> > MatrixSeq;
//typedef MSequence<Vector, VSeqAttrT<Vector> > VectorSeq;


template<class elemT, class Attr, class Cont, class Stor, class Accs>
class MSequenceBase 
   : public simth::SignalSequenceBase<elemT, Attr, Cont, Stor, Accs>
{
   public:

      typedef Stor storage_type;
      typedef Accs access_type;

      typedef elemT value_type;
      typedef Attr attributes_type;
      typedef Cont container_type;
    
      typedef typename container_type::iterator iterator;
      typedef typename container_type::const_iterator const_iterator;

      typedef typename container_type::reference reference;
      typedef typename container_type::const_reference const_reference;

      MSequenceBase(iterator iterStart, iterator iterEnd, storage_type &seq);

      MSequenceBase(storage_type &seq);

    
      virtual ~MSequenceBase() = 0;


      MSequenceBase<value_type, attributes_type, container_type,
            storage_type, access_type>&
      operator=(const MSequenceBase<value_type, attributes_type,
        container_type, storage_type, access_type> &seq);

   protected:

      MSequenceBase();

   private:
      typedef simth::SignalSequenceBase<elemT, Attr, Cont, Stor, Accs> 
        base_type;
};

template<class elemT, class Attr, class Cont> 
class MSequence : public MSequenceBase<elemT, Attr, Cont, 
                       MSequenceStorage<elemT, Attr, Cont>,
                       MSequenceAccess<elemT, Attr, Cont> >
{
   public:
      typedef MSequenceStorage<elemT,Attr,Cont> storage_type;
      typedef MSequenceAccess<elemT,Attr,Cont> access_type;

      typedef elemT value_type;
      typedef Attr attributes_type;
      typedef Cont container_type;

      typedef typename container_type::iterator iterator;
      typedef typename container_type::const_iterator const_iterator;

      typedef typename container_type::reference reference;
      typedef typename container_type::const_reference const_reference;

      typedef MSequenceBase<elemT, Attr, Cont, 
                storage_type, access_type> base_type;

      MSequence(iterator iterStart, iterator iterEnd, storage_type &seq);

      MSequence(storage_type &seq);


   virtual ~MSequence() = 0;

   protected:
      MSequence() : base_type() {};

};

template<class elemT, class Attr, class Cont> 
class MSequenceStorage : public MSequence<elemT, Attr, Cont>
{
  public:
    typedef typename Cont::iterator iterator;
    typedef typename Cont::const_iterator const_iterator;

    typedef typename Cont::reference reference;
    typedef typename Cont::const_reference const_reference;

    typedef elemT value_type;
    typedef Attr attributes_type;
    typedef Cont container_type;

    MSequenceStorage();

    MSequenceStorage(size_t size, const value_type &val = value_type());

    MSequenceStorage(const MSequence<value_type,attributes_type,container_type> &seq);

    virtual ~MSequenceStorage();

      /*MSequenceStorage<value_type, attributes_type, container_type>&
    operator=(const MSequence<value_type, attributes_type,
    container_type> &seq);*/
      
    size_t capacity() const { return ownStorage.capacity(); }

    virtual void resize(size_t i);

    attributes_type& wAttributes();

    const attributes_type& rAttributes() const { return attributes_; }

    void lock() {lock_ = true;}

    void unlock() {lock_= false;}

    bool isLocked() const {return lock_;}

  private:
    container_type ownStorage; //must be created on the heap!
    attributes_type attributes_ ;
    bool lock_;  
        
    void invariante() const;
  private:
    typedef MSequence<elemT,Attr,Cont> base_type;
};

template<class elemT, class Attr, class Cont> 
class MSequenceAccess : public MSequence<elemT, Attr, Cont>
{
   private:
      typedef MSequence<elemT,Attr,Cont> base_type;

   public:
      typedef typename base_type::value_type value_type;
      typedef typename base_type::attributes_type attributes_type;    
      typedef typename base_type::container_type container_type;
      
      typedef typename base_type::iterator iterator;
      typedef typename base_type::const_iterator const_iterator;

      typedef typename base_type::reference reference;
      typedef typename base_type::const_reference const_reference;

      typedef typename base_type::storage_type storage_type;
       
      MSequenceAccess(iterator iterStart, iterator iterEnd, storage_type &seq)
     : base_type (iterStart, iterEnd, seq) {};

      MSequenceAccess(const MSequence<elemT,Attr,Cont>& seq)
     : base_type (seq) {};
};



template<class elemT>
class MSeqAttrT {
   private:
      int dim1, dim2;
      elemT _default_elem;
   public:
      MSeqAttrT(int dim1_ = 0, int dim2_ = 0);
      MSeqAttrT(const elemT&);

      virtual ~MSeqAttrT() {};

      const elemT& defaultElem() const;
      bool operator==(const MSeqAttrT<elemT>& a) const 
      { return (dim1 == a.dim1) && (dim2 == a.dim2); }
      bool operator!=(const MSeqAttrT<elemT>& a) const 
      { return !operator==(a); }
};

template<class elemT>
class MFreqSeqAttrT : public MSeqAttrT<elemT>, 
              public simth::FreqSignalAttributes
{
   public:
      MFreqSeqAttrT(int dim1_ = 0, int dim2_ = 0)
     : MSeqAttrT<elemT>(dim1_, dim2_) {};

      MFreqSeqAttrT(const elemT& default_elem)
     : MSeqAttrT<elemT>(default_elem) {};

      bool operator==(const MFreqSeqAttrT<elemT>& a) const; 
      bool operator!=(const MFreqSeqAttrT<elemT>& a) const; 
};

template<class elemT>
class MTimeSeqAttrT : public MSeqAttrT<elemT>, 
              public simth::TimeSignalAttributes
{
   public:
      MTimeSeqAttrT(int dim1_ = 0, int dim2_ = 0)
     : MSeqAttrT<elemT>(dim1_, dim2_) {};

      MTimeSeqAttrT(const elemT& default_elem)
     : MSeqAttrT<elemT>(default_elem) {};

      bool operator==(const MTimeSeqAttrT<elemT>& a) const; 
      bool operator!=(const MTimeSeqAttrT<elemT>& a) const; 
};


template<class elemT>
class VSeqAttrT {
   private:
      int dim;
      elemT _default_elem;
   public:
      VSeqAttrT(int dim_ = 0);
      VSeqAttrT(const elemT&);

      virtual ~VSeqAttrT() {};

      VSeqAttrT<elemT>& operator=(const simth::NoAttributes& a)
      { return *this; };

      const elemT& defaultElem() const;
      bool operator==(const VSeqAttrT<elemT>& a) const 
      { return (dim == a.dim); }
      bool operator==(const simth::NoAttributes& a) const 
      { return true; }
      bool operator!=(const VSeqAttrT<elemT>& a) const 
      { return !operator==(a); }
      bool operator!=(const simth::NoAttributes& a) const 
      { return !operator==(a); }
};

template<class elemT>
class VTimeSeqAttrT : public VSeqAttrT<elemT>, 
              public simth::TimeSignalAttributes
{
   public:
      VTimeSeqAttrT(int dim_ = 0) 
     : VSeqAttrT<elemT>(dim_) {};

      VTimeSeqAttrT(const elemT& default_elem) 
     : VSeqAttrT<elemT>(default_elem) {};

      VTimeSeqAttrT<elemT>& operator=(const simth::TimeSignalAttributes& a);

      bool operator==(const VTimeSeqAttrT<elemT>& a) const; 
      bool operator==(const simth::TimeSignalAttributes& a) const; 
      bool operator!=(const VTimeSeqAttrT<elemT>& a) const; 
      bool operator!=(const simth::TimeSignalAttributes& a) const; 
};

} // namespace mimo

#endif // MATRIXSEQ_H

---