OptimizerAlg.hxx

Go to the documentation of this file.

// Copyright (C) 2006-2016  CEA/DEN, EDF R&D
//
// 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

#ifndef __OPTIMIZERALG_HXX__
#define __OPTIMIZERALG_HXX__

#include <string>

#include "YACSlibEngineExport.hxx"
#include "RefCounter.hxx"
#include "Exception.hxx"
#include "AlternateThread.hxx"
#include "Pool.hxx"
#include "TypeCode.hxx"

namespace YACS
{
  namespace ENGINE
  {
    class Proc;

    class YACSLIBENGINE_EXPORT OptimizerAlgBase : public RefCounter
    {
    protected:
      Pool *_pool;
      Proc * _proc;
      std::string _errorMessage;
      int _nbOfBranches;

    protected:
      OptimizerAlgBase(Pool *pool);
      virtual ~OptimizerAlgBase();

      // Methods to implement in real algorithm classes. These methods shall be called
      // only through proxy methods.
      virtual TypeCode *getTCForIn() const = 0;
      virtual TypeCode *getTCForOut() const = 0;
      virtual TypeCode *getTCForAlgoInit() const;
      virtual TypeCode *getTCForAlgoResult() const;
      virtual void initialize(const Any *input) throw (Exception);
      virtual void start() = 0;
      virtual void takeDecision() = 0;


      virtual void finish();
      virtual Any * getAlgoResult();

    public:
      // Proxy methods to encapsulate the call to real methods
      virtual TypeCode *getTCForInProxy() const;
      virtual TypeCode *getTCForOutProxy() const;
      virtual TypeCode *getTCForAlgoInitProxy() const;
      virtual TypeCode *getTCForAlgoResultProxy() const;
      virtual void initializeProxy(const Any *input) throw (Exception);
      virtual void startProxy();
      virtual void takeDecisionProxy();
      virtual void finishProxy();
      virtual Any * getAlgoResultProxy();

      // Utility methods
      virtual void setPool(Pool *pool);
      virtual void setProc(Proc * proc);
      virtual Proc * getProc();
      virtual bool hasError() const;
      virtual const std::string & getError() const;
      virtual void setError(const std::string & message);
      void setNbOfBranches(int nbOfBranches);
      int getNbOfBranches() const;
    };

    typedef OptimizerAlgBase OptimizerAlgSync;

    class YACSLIBENGINE_EXPORT OptimizerAlgASync : public OptimizerAlgBase,
                                                   public YACS::BASES::AlternateThread
    {
    protected:
      OptimizerAlgASync(Pool *pool);
    public:
      virtual ~OptimizerAlgASync();
      virtual void finishProxy();

    protected:
      virtual void start();
      virtual void takeDecision();


      virtual void run();

      virtual void startToTakeDecision()=0;
    };

    typedef OptimizerAlgBase *(*OptimizerAlgBaseFactory)(Pool *pool);
  }
}

#endif