param.h

/*
 *  Definition of Lorene class Param
 *
 */

/*
 *   Copyright (c) 1999-2005 Eric Gourgoulhon
 *   Copyright (c) 2000-2003 Jerome Novak
 *
 *   This file is part of LORENE.
 *
 *   LORENE is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   LORENE 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifndef __PARAM_H_ 
#define __PARAM_H_ 


/*
 * $Id: param.h,v 1.9 2014/10/13 08:52:36 j_novak Exp $
 * $Log: param.h,v $
 * Revision 1.9  2014/10/13 08:52:36  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.8  2006/06/15 08:15:36  j_novak
 * Removed members linked to Qtenseur objects.
 * Added members for Matrice objects.
 *
 * Revision 1.7  2005/08/13 16:08:20  m_saijo
 * Corrected the documents related to the Star
 *
 * Revision 1.6  2005/08/13 16:03:36  m_saijo
 * Added storage of a Star
 *
 * Revision 1.5  2005/03/24 21:55:58  e_gourgoulhon
 * Added storage of a Scalar.
 *
 * Revision 1.4  2004/03/22 13:12:43  j_novak
 * Modification of comments to use doxygen instead of doc++
 *
 * Revision 1.3  2003/09/25 12:08:02  j_novak
 * Tensors can be stored in Param objects
 *
 * Revision 1.2  2002/09/19 09:52:42  j_novak
 * Added objects Qtenseur and Qmetrique for 4D tensor and metric handling.
 *
 * Revision 1.1.1.1  2001/11/20 15:19:27  e_gourgoulhon
 * LORENE
 *
 * Revision 1.10  2001/10/27  09:26:24  novak
 * *** empty log message ***
 *
 * Revision 1.9  2001/10/11 07:44:12  eric
 * Ajout du stokage des Etoile's
 *
 * Revision 1.8  2000/10/24  14:54:49  novak
 * Added the function clean_all()
 *
 * Revision 1.7  2000/05/25 12:39:19  eric
 * MODIFICATION MAJEURE: pour les int et les double, ce sont desormais les
 * adresses qui sont stokees, et non plus les nombres eux-memes
 * (le traitement des int et des double est donc desormais completement
 * aligne sur celui des Tbl, Cmp, etc...)
 *
 * Revision 1.6  1999/12/29  13:10:39  eric
 * Ajout du stokage des Mtbl_cf.
 *
 * Revision 1.5  1999/12/27  12:16:43  eric
 * Ajout du stokage des mappings (class Map).
 *
 * Revision 1.4  1999/12/16  10:27:40  eric
 * Ajout des membres modifiables.
 * Par defaut, les objets listes sont const.
 *
 * Revision 1.3  1999/12/15  16:49:52  eric
 * *** empty log message ***
 *
 * Revision 1.2  1999/12/15  16:22:36  eric
 * Changement de l'ordre des arguments dans add_*
 * Argument par defaut: position = 0
 * Ajout du stokage des int et des double.
 *
 * Revision 1.1  1999/12/13  14:35:56  eric
 * Initial revision
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/param.h,v 1.9 2014/10/13 08:52:36 j_novak Exp $
 *
 */

namespace Lorene {
class Tbl ; 
class Itbl ;
class Matrice ; 
class Mtbl_cf ; 
class Map ; 
class Cmp ; 
class Tenseur ;
class Tensor ;
class Scalar ; 
class Etoile ;
class Star ;

class Param {

    // Data : 
    // -----
    private:
    int n_int ; 
    const int** p_int ; 

    int n_int_mod ; 
    int** p_int_mod ;   

    int n_double ; 
    const double** p_double ; 

    int n_double_mod ; 
    double** p_double_mod ; 


    int n_tbl ; 
    const Tbl** p_tbl ; 
    
    int n_tbl_mod ; 
    Tbl** p_tbl_mod ;   
    
    int n_itbl ;    
    const Itbl** p_itbl ;   
    
    int n_itbl_mod ;    
    Itbl** p_itbl_mod ; 
    
    int n_matrice ; 
    const Matrice** p_matrice ; 
    
    int n_matrice_mod ; 
    Matrice** p_matrice_mod ;   
    
    int n_cmp ; 
    const Cmp** p_cmp ; 
    
    int n_cmp_mod ; 
    Cmp** p_cmp_mod ;   
    
    int n_tenseur ; 
    const Tenseur** p_tenseur ; 
    
    int n_tenseur_mod ; 
    Tenseur** p_tenseur_mod ;   

    int n_map ; 
    const Map** p_map ; 
    
    int n_mtbl_cf ; 
    const Mtbl_cf** p_mtbl_cf ; 
    
    int n_scalar ;  
    const Scalar** p_scalar ;   
    
    int n_scalar_mod ;  
    Scalar** p_scalar_mod ;
    
    int n_tensor ;  
    const Tensor** p_tensor ;   
    
    int n_tensor_mod ;  
    Tensor** p_tensor_mod ;
    
    int n_etoile ;  
    const Etoile** p_etoile ;   

    int n_star ;    
    const Star** p_star ;   

    // Constructors - Destructor
    // -------------------------
    
    public:
    Param() ;   

    private:
    Param(const Param& ) ;
    
    public: 
    ~Param() ;  

    void clean_all() ;  



    // Assignment
    // -----------
    private: 
    void operator=(const Param& ) ;
        

    // Addition/Extraction of one element
    // ----------------------------------
    public:
    
    int get_n_int() const ; 
    
    void add_int(const int& n, int position = 0) ;
    
    const int& get_int(int position = 0) const; 

    int get_n_int_mod() const ; 
    
    void add_int_mod(int& n, int position = 0) ;
    
    int& get_int_mod(int position = 0) const; 
    

    int get_n_double() const ; 
    
    void add_double(const double& x, int position = 0) ;
    
    const double& get_double(int position = 0) const; 
    

    int get_n_double_mod() const ; 
    
    void add_double_mod(double& x, int position = 0) ;
    
    double& get_double_mod(int position = 0) const; 
    

    int get_n_tbl() const ; 
    
    void add_tbl(const Tbl& ti, int position = 0) ;
    
    const Tbl& get_tbl(int position = 0) const; 
    

    int get_n_tbl_mod() const ; 
    
    void add_tbl_mod(Tbl& ti, int position = 0) ;
    
     Tbl& get_tbl_mod(int position = 0) const; 
    

    int get_n_itbl() const ; 
    
    void add_itbl(const Itbl& ti, int position = 0) ;
    
    const Itbl& get_itbl(int position = 0) const; 
    

    int get_n_itbl_mod() const ; 
    
    void add_itbl_mod(Itbl& ti, int position = 0) ;
    
    Itbl& get_itbl_mod(int position = 0) const; 
    
    int get_n_matrice() const ; 
    
    void add_matrice(const Matrice& ti, int position = 0) ;
    
    const Matrice& get_matrice(int position = 0) const; 
    

    int get_n_matrice_mod() const ; 
    
    void add_matrice_mod(Matrice& ti, int position = 0) ;
    
     Matrice& get_matrice_mod(int position = 0) const; 
    

    int get_n_cmp() const ; 
    
    void add_cmp(const Cmp& ti, int position = 0) ;
    
    const Cmp& get_cmp(int position = 0) const; 
    

    int get_n_cmp_mod() const ; 
    
    void add_cmp_mod(Cmp& ti, int position = 0) ;
    
     Cmp& get_cmp_mod(int position = 0) const; 
    

    int get_n_tenseur() const ; 
    
    void add_tenseur(const Tenseur& ti, int position = 0) ;
    
    const Tenseur& get_tenseur(int position = 0) const; 
    

    int get_n_tenseur_mod() const ; 
    
    void add_tenseur_mod(Tenseur& ti, int position = 0) ;
    
     Tenseur& get_tenseur_mod(int position = 0) const; 
    
    int get_n_map() const ; 
    
    void add_map(const Map& mi, int position = 0) ;
    
    const Map& get_map(int position = 0) const; 
    
    int get_n_mtbl_cf() const ; 
    
    void add_mtbl_cf(const Mtbl_cf& mi, int position = 0) ;
    
    const Mtbl_cf& get_mtbl_cf(int position = 0) const; 
    
    int get_n_scalar() const ; 
    
    void add_scalar(const Scalar& ti, int position = 0) ;
    
    const Scalar& get_scalar(int position = 0) const; 
    

    int get_n_scalar_mod() const ; 
    
    void add_scalar_mod(Scalar& ti, int position = 0) ;
    
     Scalar& get_scalar_mod(int position = 0) const; 


    int get_n_tensor() const ; 
    
    void add_tensor(const Tensor& ti, int position = 0) ;
    
    const Tensor& get_tensor(int position = 0) const; 
    

    int get_n_tensor_mod() const ; 
    
    void add_tensor_mod(Tensor& ti, int position = 0) ;
    
     Tensor& get_tensor_mod(int position = 0) const; 

    int get_n_etoile() const ;

    void add_etoile(const Etoile& eti, int position = 0) ;
    
    const Etoile& get_etoile(int position = 0) const;
    
    int get_n_star() const ;

    void add_star(const Star& eti, int position = 0) ;
    
    const Star& get_star(int position = 0) const;
    
 };

}
#endif