STK_IRunner.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
 This program 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 of the
 License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANYArray_; without even the implied warranty of
 MERCHANTABILIYArray_ 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 program; if not, write to the
 Free Software Foundation, Inc.,
 59 Temple Place,
 Suite 330,
 Boston, MA 02111-1307
 USA
 
 Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 */
 
/*
 * Project:  stkpp::Sdk
 * created on: 29 juil. 2011
 * Purpose:  main interface base class for running method.
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_IRUNNER_H
#define STK_IRUNNER_H
 
#include <STKernel/include/STK_String.h>
namespace STK
{
class IRunnerBase
{
  protected:
    inline IRunnerBase() : msg_error_(), hasRun_(false) {}
    inline IRunnerBase( IRunnerBase const& runner)
                      : msg_error_(runner.msg_error_)
                      , hasRun_(runner.hasRun_){}
    inline virtual ~IRunnerBase() {}
 
  public:
    inline String const& error() const { return msg_error_;}
    virtual bool run() =0;
 
  protected:
    inline virtual void update() {}
    String msg_error_;
    bool hasRun_;
};
 
template < class Array>
class IRunnerWithData: public IRunnerBase
{
  protected:
    inline IRunnerWithData() : p_data_(0) {}
    inline IRunnerWithData( Array const* const p_data) : p_data_(p_data) {}
    inline IRunnerWithData( Array const& data) : p_data_(&data) {}
    inline IRunnerWithData( IRunnerWithData const& runner)
                          : IRunnerBase(runner)
                          , p_data_(runner.p_data_)
    {}
    inline ~IRunnerWithData() {}
 
  public:
    inline Array const* p_data() const { return p_data_;}
    inline virtual void setData( Array const* p_data)
    {
      p_data_ = p_data;
      update();
      this->hasRun_ = false;
    }
    inline virtual void setData( Array const& data)
    {
      p_data_ = &data;
      update();
      this->hasRun_ = false;
    }
 
  protected:
    Array const* p_data_;
};
 
template < class Array, class Weights_>
class IRunnerUnsupervised: public IRunnerBase
{
  protected:
  inline IRunnerUnsupervised() : p_data_(0) {}
    inline IRunnerUnsupervised( Array const* const p_data) : p_data_(p_data) {}
    inline IRunnerUnsupervised( Array const& data) : p_data_(&data) {}
    inline IRunnerUnsupervised( IRunnerUnsupervised const& runner)
                              : IRunnerBase(runner)
                              , p_data_(runner.p_data_)
    {}
    inline ~IRunnerUnsupervised() {}
 
  public:
    inline Array const* p_data() const { return p_data_;}
    inline virtual void setData( Array const* p_data)
    {
      p_data_ = p_data;
      update();
    }
    inline virtual void setData( Array const& data)
    {
      p_data_ = &data;
      update();
      this->hasRun_ = false;
    }
    virtual bool run() =0;
    virtual bool run( Weights_ const& weights) =0;
 
  protected:
    Array const* p_data_;
};
 
template < typename YArray_, typename XArray_, class Weights_>
class IRunnerSupervised: public IRunnerBase
{
  protected:
    IRunnerSupervised(): p_y_(0), p_x_(0) {}
    IRunnerSupervised( YArray_ const* const& p_y, XArray_ const* const& p_x)
                     : p_y_(p_y), p_x_(p_x)
    {}
    IRunnerSupervised( YArray_ const& y, XArray_ const& x)
                     : p_y_(&y), p_x_(&x)
    {}
    IRunnerSupervised( IRunnerSupervised const& runner)
                     : IRunnerBase(runner)
                     , p_y_(runner.p_y_), p_x_(runner.p_x_)
    {}
    inline ~IRunnerSupervised() {}
 
  public:
    virtual void setX( XArray_ const& x)
    {
      p_x_ = &x;
      updateX();
      this->hasRun_ = false;
    }
 
    virtual void setY( YArray_ const& y)
    {
      p_y_ = &y;
      updateY();
      this->hasRun_ = false;
    }
    virtual void setData( YArray_ const& y, XArray_ const& x)
    {
      p_y_ = &y;
      p_x_ = &x;
      update();
      this->hasRun_ = false;
    }
    virtual bool run() =0;
    virtual bool run( Weights_ const& weights) =0;
 
  protected:
    YArray_ const* p_y_;
    XArray_ const* p_x_;
    virtual void updateY() {}
    virtual void updateX() {}
    virtual void update() { updateX(); updateY();}
};
 
} // namespace STK
 
#endif /* STK_IRUNNER_H */