softoutdecodingfactory.h

Go to the documentation of this file.

/*-*-c++-*-****************************************************************
                          sofoutdecodingfactory.h  -  description
                             -------------------
    begin                : Mit Mai 22 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 SOFOUTDECODINGFACTORY_HEADER
#define SOFOUTDECODINGFACTORY_HEADER

#include <iostream>
#include <string>
#include <complex>
#include <memory>


#include "misc.h"
#include "signals.h"
#include "basicdevice.h"
#include "softoutdecoding.h"
#include "trellissoftout.h"

namespace simthlib
{

/* These classes are so called factory classes (see "Die C++ Programiersprache", page S.~342) for
    different SoftoutDecoding classes.
 
*/
class SoftoutDecodingMaker
{
  public:

    virtual SoftoutDecoding* newSoftoutDecoding() const = 0;

    virtual ~SoftoutDecodingMaker(){};
};

class StreamSoftoutDecodingMaker : public SoftoutDecodingMaker
{
  public:

    virtual StreamSoftoutDecoding* newSoftoutDecoding() const = 0;

    virtual ~StreamSoftoutDecodingMaker(){};
};

class StreamSoftoutDecodingTailbitsMaker : public StreamSoftoutDecodingMaker
{
  public:

    virtual StreamSoftoutDecodingTailbits* newSoftoutDecoding() const = 0;

    virtual ~StreamSoftoutDecodingTailbitsMaker(){};
};

class TrellisSoftoutDecodingMaker : public StreamSoftoutDecodingTailbitsMaker
{
  public:

    virtual TrellisSoftoutDecoding* newSoftoutDecoding() const = 0;

    virtual ~TrellisSoftoutDecodingMaker(){};
};



class ConvSoftoutDecodingMaker : public TrellisSoftoutDecodingMaker
{
    int inSymbolsPerStep;
    int bitsPerSymbol;
    simthlib::ConvCodeTrellis::StartingMode startingMode;

    bool mapping;
    simthlib::map_type mapMode;

    simth::checkedVector<int> polynome;
    int recursivePolynomial;

    bool systematic;

    int mem;
    int outbits;

    trellissoftout::softoutalgorithmmode soMode;

  public:
    ConvSoftoutDecodingMaker(int mem_, int inbits_, int outbits_,
                            trellissoftout::softoutalgorithmmode soMode_)
        : inSymbolsPerStep(inbits_),bitsPerSymbol(1), startingMode(simthlib::ConvCodeTrellis::ZERO),
        mapping(false), mapMode(simthlib::NATURAL),
        polynome(0),recursivePolynomial(-1), systematic(false),
    mem(mem_), outbits(outbits_), soMode(soMode_) {}

    ConvSoftoutDecodingMaker(int inSymbolsPerStep_, const simth::checkedVector<int>& polynome_,
                              trellissoftout::softoutalgorithmmode soMode_)
        : inSymbolsPerStep(inSymbolsPerStep_),bitsPerSymbol(1), startingMode(simthlib::ConvCodeTrellis::ZERO),
        mapping(false), mapMode(simthlib::NATURAL),
        polynome(polynome_),recursivePolynomial(0), systematic(false),
    mem(-1), outbits(-1), soMode(soMode_) {}

    ConvSoftoutDecodingMaker(int inSymbolsPerStep_, const simth::checkedVector<int>& polynome_,
                            int recursivePolynomial_, bool systematic_,
                            trellissoftout::softoutalgorithmmode soMode_)
        : inSymbolsPerStep(inSymbolsPerStep_),bitsPerSymbol(1), startingMode(simthlib::ConvCodeTrellis::ZERO),
        mapping(false), mapMode(simthlib::NATURAL),
        polynome(polynome_),recursivePolynomial(recursivePolynomial_), systematic(systematic_),
    mem(-1), outbits(-1), soMode(soMode_) {}

    ConvSoftoutDecodingMaker(int inSymbolsPerStep_, int bitsPerSymbol_,simthlib::ConvCodeTrellis::StartingMode startingMode_, simthlib::map_type mapMode_,
                            const simth::checkedVector<int>& polynome_, int recursivePolynomial_,
                            trellissoftout::softoutalgorithmmode soMode_)
        : inSymbolsPerStep(inSymbolsPerStep_), bitsPerSymbol(bitsPerSymbol_), startingMode(startingMode_),
        mapping(true), mapMode(mapMode_),
        polynome(polynome_),recursivePolynomial(recursivePolynomial_), systematic(false),
    mem(-1), outbits(-1), soMode(soMode_){}

    virtual ConvSoftoutDecoding* newSoftoutDecoding() const;
};


inline ConvSoftoutDecoding* ConvSoftoutDecodingMaker::newSoftoutDecoding() const
{
  if(DEBUG) {
    if( (polynome.size() == 0)&&(mem <= 0)) {
      throw std::logic_error("inline ConvSoftoutDecoding* ConvSoftoutDecodingMaker::newSoftoutDecoding()"
                             " : Error 1");
    }
  }
  if(!mapping) {
    if(polynome.size() != 0) {
      return new ConvSoftoutDecoding(inSymbolsPerStep, polynome, recursivePolynomial,systematic,
                                    soMode);
    }
    else {
      return new ConvSoftoutDecoding(mem, inSymbolsPerStep, outbits, soMode);
    }
  }
  else {
    if(DEBUG) {
      if(polynome.size() == 0) {
        throw std::logic_error("inline ConvSoftoutDecoding* ConvSoftoutDecodingMaker::newSoftoutDecoding() "
                               "const : error 1");
      }
    }
    return new ConvSoftoutDecoding(inSymbolsPerStep, bitsPerSymbol, startingMode, mapMode, polynome,
                                  recursivePolynomial, soMode);
  }
}


class ConvSoftoutDecodingExplicitMaker : public TrellisSoftoutDecodingMaker
{

  public:

    ConvSoftoutDecodingExplicitMaker(int inbits, int outbits, ConvCodeTrellis::StartingMode startingMode_,
                     map_type mappMode_,trellissoftout::softoutalgorithmmode mode)
       : inputBitsPerStep(inbits),outputBitsPerStep(outbits),startingMode(startingMode_),mappMode(mappMode_),soMode(mode)
      { }; 


    virtual TrellisSoftoutDecoding* newSoftoutDecoding() const;

  private:
  
    int inputBitsPerStep;
    int outputBitsPerStep;
    simthlib::ConvCodeTrellis::StartingMode startingMode;
    map_type mappMode;
    trellissoftout::softoutalgorithmmode soMode;
};


inline TrellisSoftoutDecoding* ConvSoftoutDecodingExplicitMaker::newSoftoutDecoding() const
{
    std::auto_ptr<TrellisSoftoutAlgorithm> algorithmPtr = makeExplicitSoftoutAlgorithm(soMode,inputBitsPerStep, outputBitsPerStep,startingMode,mappMode);
    return new TrellisSoftoutDecoding(algorithmPtr);
}


class SoftoutDAPSKDecodingMaker : public StreamSoftoutDecodingTailbitsMaker
{

    int inSymbolsPerStep;
    int bitsPerSymbol;
    simthlib::ConvCodeTrellis::StartingMode startingMode;

    bool mapping;
    simthlib::map_type mapMode;

    simth::checkedVector<int> polynome;
    int recursivePolynomial;

    trellissoftout::softoutalgorithmmode soMode;

  public:

    SoftoutDAPSKDecodingMaker(int inSymbolsPerStep_, int bitsPerSymbol_,simthlib::ConvCodeTrellis::StartingMode startingMode_, 
                             simthlib::map_type mapMode_,
                             const simth::checkedVector<int>& polynome_, int recursivePolynomial_, 
                             trellissoftout::softoutalgorithmmode soMode_)
        : inSymbolsPerStep(inSymbolsPerStep_),bitsPerSymbol(bitsPerSymbol_), startingMode(startingMode_),
        mapping(true), mapMode(mapMode_),
      polynome(polynome_),recursivePolynomial(recursivePolynomial_),soMode(soMode_)
    {}

    virtual StreamSoftoutDecodingTailbits* newSoftoutDecoding() const;
};

inline StreamSoftoutDecodingTailbits* SoftoutDAPSKDecodingMaker::newSoftoutDecoding() const
{
  if(DEBUG) {
    if(polynome.size() == 0) {
      throw std::logic_error("inline StreamSoftoutDecoding* ConvSoftoutDecodingMaker::newSoftoutDecoding() "
                             "const : error 1");
    }
  }
  return new SoftoutDAPSKDecoding(inSymbolsPerStep, bitsPerSymbol, startingMode, mapMode, polynome, recursivePolynomial,soMode);
}



class PunctConvSoftoutDecodingMaker : public StreamSoftoutDecodingTailbitsMaker
{
    int codeRateNumerator;
    int codeRateDenumerator;

    simth::checkedVector<int> polynome;
    int recursivePolynomial;

    bool systematic;

    int mem;
    int inbits;
    int outbits;

    std::string pattern;

    trellissoftout::softoutalgorithmmode soMode;

  public:
    PunctConvSoftoutDecodingMaker(int codeRateNumerator_, int codeRateDenumerator_,
                                 int mem_, int inbits_, int outbits_,
                                 trellissoftout::softoutalgorithmmode soMode_)
        : codeRateNumerator(codeRateNumerator_), codeRateDenumerator(codeRateDenumerator_),
        polynome(0),recursivePolynomial(-1), systematic(false),
    mem(mem_), inbits(inbits_), outbits(outbits_), soMode(soMode_) {}

    PunctConvSoftoutDecodingMaker(int inbits_, int codeRateNumerator_, int codeRateDenumerator_,
                                 const simth::checkedVector<int>& polynomePar,
                                 int recursivePolynomialPar,bool  systematic_,
                                 trellissoftout::softoutalgorithmmode soMode_)
        : codeRateNumerator(codeRateNumerator_), codeRateDenumerator(codeRateDenumerator_),
        polynome(polynomePar),recursivePolynomial(recursivePolynomialPar), systematic(systematic_),
    mem(-1), inbits(inbits_), outbits(-1), soMode(soMode_) {}

    PunctConvSoftoutDecodingMaker(int inbits_, const std::string& punctPattern,
                                 const simth::checkedVector<int>& polynomePar,
                                 int recursivePolynomialPar,bool  systematic_,
                                 trellissoftout::softoutalgorithmmode soMode_)
        : codeRateNumerator(-1), codeRateDenumerator(-1),
        polynome(polynomePar),recursivePolynomial(recursivePolynomialPar), systematic(systematic_),
    mem(-1), inbits(inbits_), outbits(-1), pattern(punctPattern), soMode(soMode_) {}

    virtual StreamSoftoutDecodingTailbits* newSoftoutDecoding() const;
};

inline StreamSoftoutDecodingTailbits* PunctConvSoftoutDecodingMaker::newSoftoutDecoding() const
{
  if(DEBUG) {
    if( (polynome.size() == 0)&&(mem <= 0)) {
      throw std::logic_error("inline StreamSoftoutDecoding* PunctConvSoftoutDecodingMaker::newSoftoutDecoding()"
                             " : Error 1");
    }
  }
  if(polynome.size() != 0) {
    if(pattern.length()==0) {
      return new PunctConvSoftoutDecoding(codeRateNumerator, codeRateDenumerator, inbits, polynome,
                                          recursivePolynomial, systematic, soMode);
    }
    return new PunctConvSoftoutDecoding(pattern, inbits, polynome, recursivePolynomial,systematic,
                                        soMode);
  }
  else {
    return new PunctConvSoftoutDecoding(codeRateNumerator, codeRateDenumerator, mem,inbits,outbits,
                                        soMode);
  }
}


}

#endif

---