Objet_U.h

/****************************************************************************
* Copyright (c) 2026, CEA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
 
 
#ifndef Objet_U_included
#define Objet_U_included
 
//     On rencontre des fous
//     qui #define min max ou throw!
#undef min
#undef max
#undef throw
 
#include <assert.h>
#include <DecBaseInst.h>
 
#ifdef LATATOOLS
#include <LataJournal.h>
#include <Sortie.h>
#include <Entree.h>
#define Cerr Journal()
#define finl std::endl
#define tspace " "
 
#else
#include <EntreeSortie.h>
#endif
 
#include <Process.h>
 
class Type_info;
class Interprete;
class Motcle;
class Param; // need this forward for pure virtual set_param
 
/*! @brief classe Objet_U Cette classe est la classe de base des Objets de TRUST
 *
 *      Dans les classes derivees de Objet_U, on ajoute toujours
 *       une macro Declare_instanciable ou Declare_base qui donne aux
 *       objets les proprietes suivantes:
 *      Un Objet_U peut etre lu dans une Entree ou ecrit dans une Sortie
 *       (entree/sortie standard, jeu de donnees .data, fichier disque,
 *        buffer memoire, buffer de communication parallele).
 *        Il faut donc toujours implementer les methodes readOn et printOn
 *      Un Objet_U d'un type quelconque peut etre instancie grace a une
 *       chaine de caracteres qui l'identifie (que_suis_je()), voir OWN_PTR::typer
 *      Un Objet_U peut etre "sauvegarde" ou "repris" sur disque (au sens sauvegarde
 *       et reprise d'un calcul). Ces operations sont differentes de readOn/printOn
 *       car elles permettent eventuellement une redistribution des donnees paralleles
 *       ou des changements de version.
 *      Un Objet_U, s'il est "Declare_instanciable", peut etre cree dynamiquement et lu
 *       dans le jeu de donnees TRUST (a travers readOn). Il possede alors le nom
 *       (le_nom()) attribue dans le jeu de donnees (voir les classes Interprete_bloc et Lire)
 *      Un Objet_U fait l'objet d'une gestion memoire speciale par le noyau permettant
 *       le debuggage et l'optimisation (operations specifiques a la creation,
 *       a la destruction et a la copie)
 *
 * @sa Memoire Objet_U_ptr Process, Classe abstraite
 */
class Objet_U : public Process
{
public:
  friend class Sortie;
  friend class Entree;
 
  ~Objet_U() override;
  int        numero() const;
  virtual int    duplique()  const =0;
  virtual Sortie&   printOn(Sortie& ) const;
  virtual Entree&   readOn(Entree& ) ;
  virtual unsigned  taille_memoire() const =0;
  virtual int    est_egal_a(const Objet_U&) const;
  virtual const Nom& le_nom() const;
  static double precision_geom;
 
  virtual void       nommer(const Nom&);
  virtual int    reprendre(Entree& ) ;
  virtual int    sauvegarder(Sortie& ) const;
 
 
#ifndef LATATOOLS            // All the below is not needed in lata_tools:
  int        get_object_id() const;
 
  // Elie Saikali : add to this to statically test if class templates are REF/OWN_PTR or normal !
  static constexpr bool HAS_POINTER = false;
 
  static int dimension;
  static int format_precision_geom;
  static int axi;
  static int bidim_axi;
  static int DEACTIVATE_SIGINT_CATCH; // flag to not enter the overloaded function signal_callback_handler
  static const Nom& nom_du_cas();
  static Nom& get_set_nom_du_cas();
 
  static Type_info         info_obj;
  virtual const Type_info* get_info() const;
  static const Type_info*  info();
 
  const Nom&         que_suis_je() const;
  const char*        le_type() const;
 
  friend int     operator ==(const Objet_U&, const Objet_U&);
  friend int     operator !=(const Objet_U&, const Objet_U&);
  virtual int    change_num(const int* const );
  virtual int lire_motcle_non_standard(const Motcle& motlu, Entree& is);
  virtual int    associer_(Objet_U&) ;
  const Interprete& interprete() const;
  Interprete& interprete();
  /* methode rajoutee pour caster en python */
  static const Objet_U& self_cast(const Objet_U&);
  static Objet_U& self_cast( Objet_U&);
 
  static bool disable_TU; // Flag to disable the writing of the .TU files
  static bool stat_per_proc_perf_log; // Flag to enable the writing of the statistics detailed per processor in _csv.TU file
protected:
  Objet_U();
  Objet_U(const Objet_U&);
  const Objet_U& operator=(const Objet_U&);
 
  // not pure virtual because that would need adapting every derived of Objet_U
  // and not needed since the macro Declare_xxx_with_param forces to define this anyway
  // eventually, should only be implemented in derived of Objet_U_With_Params
  virtual void set_param(Param&) const {}
 
private:
  // Numero de l'objet (indice de l'objet dans Memoire::data)
  // Ce numero peut changer entre la construction et la destruction.
  int _num_obj_;
  // Identifiant unique de l'objet (attribue par le constructeur,
  // et jamais modifie ensuite).
  const int object_id_;
 
  // Compteur d'objets crees (incremente par le constructeur).
  static int static_obj_counter_;
  static Interprete* l_interprete;
 
#endif
};
 
#ifndef LATATOOLS
int operator==(const Objet_U& x, const Objet_U& y) ;
int operator!=(const Objet_U& x, const Objet_U& y) ;
#endif
 
#endif