/*******************************************************
*
*  DESCRIPTION: class OutputQuantizer 
*
*  AUTHOR: Mariana C. D'Abreu
*
*  EMAIL: mdabreu@dc.uba.ar
*
********************************************************/

#ifndef _OUTPUT_QUANTIZER_H
#define _OUTPUT_QUANTIZER_H

#include "quantizer.h"
#include "except.h"
#include "vlist.h"

class OutputQuantizer {

  public:

    OutputQuantizer( const string &quantMethod );
    OutputQuantizer( const string &quantMethod, const double hystWindow );
    virtual ~OutputQuantizer();

    //--- Getters ---//
    string  quantizationMethod() const 
      { return method; }
      
    double  hysteresisWindow() const 
      { return hystWindow; }
    
    bool    useHysteresis() const
      { return hysteresis; }


    //--- Setter ---//
    OutputQuantizer &hysteresisWindow( const double hystWindow );

    static bool     validMethod( const string &method );

    static string   validMethodsAsString();

    //--- Parametros del cuantificador ---//
    virtual int     paramCount() const;
      
    virtual string  getParam ( const int n ) const;
      
    virtual OutputQuantizer &setParam ( const int n, const string &value );
 
    //--- Funcion de cuantificacion ---//
    virtual bool emitOutput( const Value &value, Value* &qValue );

    virtual	void printInfo ( ostream &out );

    static const double InvalidHysteresisWindow;

  protected:

    virtual bool      quantizeValue ( const RealValue &value, Value* &qValue, const int index = 0 );
    virtual bool      quantizeList  ( const VList *value, VList* &qValue );
    virtual bool      emitValue( const Value *value );
  
  private:

    virtual RealValue hquantize( const RealValue &value, const int index = 0 );

    string        method;
    bool          firstValue;   //--- primer valor recibido
    bool          hysteresis;   //--- aplica hysteresis     
    double        hystWindow;   //--- tamanio de la ventana de histeresis
    Value         *lastQValue;  //--- valor de la ultima entrada cuantificada y emitida
    Quantizer     *quantizer;   //--- cuantificador

};  

class OutputQuantizerException: public MException
{
  public:
    
    const string type() const { return "OutputQuantizerException"; }

};    

//--- inline functions ---//
inline
bool OutputQuantizer::validMethod( const string &method )
{
  return Quantizer::validMethod( method );
}

inline
string OutputQuantizer::validMethodsAsString()
{
  return Quantizer::validMethodsAsString();
}

inline
int OutputQuantizer::paramCount() const
{ 
  assert (quantizer); 
  return quantizer->paramCount(); 
}

inline
string OutputQuantizer::getParam ( const int n ) const
{
  assert (quantizer); 
  return quantizer->getParam( n );
}

inline
OutputQuantizer &OutputQuantizer::setParam ( const int n, const string &value ) 
{
  assert (quantizer); 
  quantizer->setParam( n, value ); 
  return *this; 
}


#endif