OptimizerAlg.hxx

Go to the documentation of this file.

// Copyright (C) 2006-2026  CEA, EDF
//
// 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) ;
      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) ;
      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