/*-------------------------------------------------------------------------------------*/
/*  NOMAD - Nonsmooth Optimization by Mesh Adaptive Direct search - version 3.0.0      */
/*                                                                                     */
/*  Copyright (C) 2001-2008  Mark Abramson        - the Boeing Company, Seattle        */
/*                           Charles Audet        - Ecole Polytechnique, Montreal      */
/*                           Gilles Couture       - Ecole Polytechnique, Montreal      */
/*                           John Dennis          - Rice University, Houston           */
/*                           Sebastien Le Digabel - Ecole Polytechnique, Montreal      */
/*                                                                                     */
/*  funded in part by AFOSR and Exxon Mobil                                            */
/*                                                                                     */
/*  Author: Sebastien Le Digabel                                                       */
/*                                                                                     */
/*  Contact information:                                                               */
/*    Ecole Polytechnique de Montreal - GERAD                                          */
/*    C.P. 6079, Succ. Centre-ville, Montreal (Quebec) H3C 3A7 Canada                  */
/*    e-mail: Sebastien.Le.Digabel@gerad.ca                                            */
/*    phone : 1-514-340-6053 #6673                                                     */
/*    fax   : 1-514-340-5665                                                           */
/*                                                                                     */
/*  This program 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 3 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    */
/*  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 this  */
/*  program. If not, see <http://www.gnu.org/licenses/>.                               */
/*                                                                                     */
/*  You can find information on the NOMAD software at www.gerad.ca/nomad               */
/*-------------------------------------------------------------------------------------*/
#ifndef __PARAMETER_ENTRY__
#define __PARAMETER_ENTRY__

#include "Uncopyable.hpp"
#include "utils.hpp"
#include <set>

class Parameter_Entry : private Uncopyable {


private:

  std::string            _name;
  std::list<std::string> _values;
  bool                   _ok;
  bool                   _unique;
  bool                   _has_been_interpreted;
  Parameter_Entry      * _next;

public:

  // constructor:
  explicit Parameter_Entry ( const std::string & );

  // destructor:
  ~Parameter_Entry ( void ) {}

  // display:
  void display ( std::ostream & out ) const;

  // GET methods:
  const std::string            & get_name      ( void ) const { return _name;   }
  const std::list<std::string> & get_values    ( void ) const { return _values; }
  bool                           is_ok         ( void ) const { return _ok;     }
  bool                           is_unique     ( void ) const { return _unique; }
  Parameter_Entry              * get_next      ( void ) const { return _next;   }

  bool has_been_interpreted ( void ) const { return _has_been_interpreted;            }
  int  get_nb_values        ( void ) const { return static_cast<int>(_values.size()); }

  // SET methods:
  void set_next   ( Parameter_Entry * p ) { _next                 = p;    }
  void set_unique ( bool              u ) { _unique               = u;    }
  void set_has_been_interpreted  ( void ) { _has_been_interpreted = true; }

  // comparison of two entries (based on the name):
  bool operator < ( const Parameter_Entry & p ) const { return _name < p._name; }

};

// display:
inline std::ostream & operator << ( std::ostream          & out ,
				    const Parameter_Entry & p ) {
  p.display(out);
  return out;
}

/*-----------------------------------------------------------------*/
/*          to allow the comparison of two Parameter_Entry *'s     */
/*-----------------------------------------------------------------*/
struct Parameter_Entry_Comp {
  bool operator() ( const Parameter_Entry * p1 , const Parameter_Entry * p2 ) const {
    return (*p1 < *p2);
  }
};

#endif
