multiplexer.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 MIMOLIB_MULTIPLEXER_H
#define MIMOLIB_MULTIPLEXER_H

#include <basicdevicefactory.h>
#include <basicdevice.h>
#include <phbib.h>
#include <signals.h>

#include "matrixseq.h"

namespace mimo {

using namespace simth;

class Multiplexer : public Device
{
  protected:
    unsigned int iports;
    unsigned int oports;

    Multiplexer(int deviceID, DeviceSystemIntf* system, 
        const simth::PropertyList& pl);
    
  public:
    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    template<class seqT>
    void process();

    void print(std::ostream &os) const;

    static void init(const std::string& fileName, 
             Device** dev, 
             DeviceSystemIntf* sysPtr, 
             int ID,
             const std::string& regionQualifier);
    static void init(simth::DeviceFactory& registration);
};


template<class seqT>
class MultiplexerT : public Multiplexer
{
  public:
    MultiplexerT(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl);

    void process() 
    { Multiplexer::process<seqT>(); };
};

// specialized class template
template<>
class MultiplexerT<CMatrixSeq> : public Multiplexer
{
      typedef CMatrixSeq seqT;
   public:
      MultiplexerT(int deviceID, DeviceSystemIntf* system, 
           const simth::PropertyList& pl);
      void process() 
      { Multiplexer::process<seqT>(); };
};



    
/*********************************
 * Multiplexing into and from vectors
 */
namespace MultiplexVector {
   void init(const std::string& fileName, 
         Device** dev, 
         DeviceSystemIntf* sysPtr, 
         int ID,
         const std::string& regionQualifier);

    simth::Device* init(int ID, 
            simth::DeviceSystemIntf* sysPtr,
            const simth::PropertyList& pl, 
            const std::string& cpptype);

   template<class seqT_in, class seqT_out>
   inline void seqs_to_vector(const std::vector< seqT_in* >& iseqs, 
                  seqT_out& oseq,
                  unsigned iports)
   {
      unsigned iLength = oseq.size();
      for (unsigned n = 0; n < iLength; n++)
     for (unsigned iport = 0; iport < iports; iport++)
     {
        mimo::c_assign(oseq[n], iport, 
             iseqs[iport]->operator[](n));
     }
   }

   template<class seqT_in, class seqT_out>
   inline void seqs_to_vector(const std::vector< seqT_in* >& iseqs, 
                  seqT_out& oseq)
   {
       seqs_to_vector(iseqs, oseq, iseqs.size());
   }

   template<class seqT_in, class seqT_out>
   inline void vector_to_seqs(const seqT_in & iseq, 
                  std::vector< seqT_out* > & oseqs,
                  unsigned oports)
   {
      unsigned oLength = iseq.size();
      for (unsigned n = 0; n < oLength; n++)
     for (unsigned oport = 0; oport < oports; oport++)
     {
        if (oseqs[oport])
           oseqs[oport]->operator[](n) = 
          mimo::c_access(iseq[n], oport);
     }
   }

   template<class seqT_in, class seqT_out>
   inline void vector_to_seqs(const seqT_in & iseq, 
                  std::vector< seqT_out* > & oseqs)
   {
       vector_to_seqs(iseq, oseqs, oseqs.size());
   }

}

template<class seqT_in, class seqT_out>
class ToVector : public Device
{
  protected:
    unsigned int iports;

    
  public:
    ToVector(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl)
       : Device (deviceID, system, pl) 
       , iports(pl.PropertyList::getProperty<unsigned>("input_ports"))
       {
      insertInputInterface< seqT_in >(iports);
      insertOutputInterface< seqT_out> ();
       };

    void updateInputLengths()
       {
      setInputLength(outputLength());
       };
    void updateOutputLengths()
       {
      for (unsigned i = 0; i < iports; i++)
      {
         if (!isInputSequence(i))
        return;
      }
      setOutputLength(inputLength());
       };

    void process();

    // void print(std::ostream & /*os*/) const {};
};


template<class seqT_in, class seqT_out>
class FromVector : public Device
{
  protected:
    unsigned int oports;
    
  public:
    FromVector(int deviceID, DeviceSystemIntf* system, 
           const simth::PropertyList& pl);

    void updateInputLengths()
       {
      for (unsigned i = 0; i < oports; i++)
      {
         if (outputLength(i) == 0)
        return;
      }
      setInputLength(outputLength());
       };
    void updateOutputLengths()
       {
      setOutputLength(inputLength());
       };

    void process();

    // void print(std::ostream & /*os*/) const {};
};

template<class seqT_in, class seqT_out>
class MultiplexFromVector : public Device
{
  protected:
    unsigned int dim;
    
  public:
    MultiplexFromVector(int deviceID, DeviceSystemIntf* system, 
            const simth::PropertyList& pl);

    void updateInputLengths()
       {
      setInputLength(outputLength()/dim);
       };
    void updateOutputLengths()
       {
      setOutputLength(dim*inputLength());
       };

    void process();

    // void print(std::ostream & /*os*/) const {};
};

template<class seqT_in, class seqT_out>
class FromDiag : public Device
{
  protected:
  unsigned int n;
    
  public:
    FromDiag(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl,
         unsigned int n);

    void updateInputLengths()
       {
      setInputLength(outputLength());
       };
    void updateOutputLengths()
       {
      setOutputLength(inputLength());
       };

    void process();

    // void print(std::ostream & /*os*/) const {};
};



template<class seqT_in, class seqT_out>
class FromMat : public Device
{
  protected:
    unsigned int rows, cols;
    
  public:
    FromMat(int deviceID, DeviceSystemIntf* system, 
        const simth::PropertyList& pl);

    void updateInputLengths()
       {
      setInputLength(outputLength());
       };
    void updateOutputLengths()
       {
      setOutputLength(inputLength());
       };

    void process();

    // void print(std::ostream & /*os*/) const {};
};

} // namespace

#endif /* MIMOLIB_MULTIPLEXER_H */

---