source: trunk/yao/src/YAOObjects/Object.hpp @ 1

//! \file    Object.hpp
//! \brief   Declaration and implementation of the base Object class.
//! \version 2007/10/01 (yyyy/mm/dd) 
//! \author  Luigi Nardi <luiginardi(at)gmail.com> 
//
// This file is part of YAO, a framework for variational assimilation in
// numerical models.
// Copyright (c) 2001-onwards LOCEAN. All rights reserved.
//
// This program may be redistributed and/or modified 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.
//
// This program is provided AS IS and WITHOUT ANY WARRANTY, including any
// implied warranty of DESIGN, MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE.
//
//! \mainpage
//!
//! YAO is a software framework for variational assimilation in numerical
//! models. It aims at generating new C++ codes rather than automatically
//! generating  adjoint codes from existing softwares.
//!
//! The main idea is to break up the numerical code of the model into a graph of
//! connected modules. Each module represents a function, whose inputs are
//! connected to the outputs of the forward modules. This approach allows to 
//! build complex systems. When the model is differentiable, YAO facilitates the
//! coding of the adjoint and linear tangent of the model by handling the
//! input/outputs of the different modules. This allows to supervise the model,
//! using variational data assimilation methodology, with very few software
//! development involved.


#ifndef YAO_OBJECT_HPP_INCLUDED
#define YAO_OBJECT_HPP_INCLUDED

#include "../help/Helper.hpp"

#include <string>

//! \namespace yao
//! \brief YAO namespace.
namespace yao{

  /**
   * Object base class. Here we store the basic information for all the Yao objects that
   * inherits from this class. We redefine some operator like "less-than".
   */
  class Object{

    public:

      /**
       * Default constructor.
       * @param aName is the name of the Object.
       */
      Object(const std::string& aName=""): theName(aName) {}
      
      //!< Destructor.
      virtual ~Object() {}

      /**
       * Set the name of the Object.
       * @param aName is the name of the Object.
       */
      void setName(const std::string& aName) { theName = aName; }

      /**
       * Get the name of the Object.
       * @return the name of the Object.
       */
      const std::string& getName() const { return theName; }

      //! The number of information stored in this class.
      static int getPropertyCount() { return 1; }

      //! Get the name of the property class: "object".
      static std::string getPropertyName(int anIndex){
        ENFORCE(anIndex == 0);
        static const char* propertyName[] = { "object" };
        return propertyName[anIndex];
      }

      //! Get the name information in function of an integer that identifies it.
      virtual std::string getProperty(int anIndex) const{
        return anIndex == 0? stream_cast<std::string>(theName): "";
      }

      //! Comparison less-than operator, required for use with std::less (should
      //! better be achieved using some dedicated/specialized less-than functor).
      bool operator<(const Object& anObject) const{
        return theName < anObject.theName;
      }

    protected:

      //! The only information of the class is the object name.  
      std::string theName;
  };

} // End namespace yao.
#endif //! YAO_OBJECT_HPP_INCLUDED.