model.h

Go to the documentation of this file.

 
#ifndef SI_MODEL_MODEL_H
#define SI_MODEL_MODEL_H
 
 
#include <vector>
#include <string>
#include <set>
#include <map>
 
#include <si/model/topModel.h>
class Vertex;
 
 
namespace sigraph
{
  class Clique;

  class Model
  {
  public:
    virtual ~Model();
    virtual Model* clone() const = 0;
 
    Model & operator = ( const Model & m );


    virtual double prop( const Clique* cl ) = 0;
    virtual double prop( const Clique* cl, 
                         const std::map<Vertex*, std::string> & changes );
    virtual bool doesOutputChange( const Clique* cl, 
                                   const std::map<Vertex*,
                                   std::string> & changes ) const;
    virtual double update( const Clique* cl ) { return( prop( cl ) ); }
    virtual double update( const Clique* cl, 
                           const std::map<Vertex*, std::string> & changes );
    virtual bool isAdaptive() const;
    virtual bool openFile( const std::string & basename = "" );
    virtual void closeFile();
    virtual void subFiles( const std::string & prefix, 
                           std::set<std::string> & listNames ) const;
    virtual double printDescription( Clique* cl, bool withnames = false );


    virtual Model* parent();
    virtual void setParent( Model* m );
    virtual TopModel* topModel();
    virtual const TopModel* topModel() const;
    virtual carto::AttributedObject* graphObject();
    virtual const carto::AttributedObject* graphObject() const;


    virtual void buildTree( Tree & tr ) const = 0;
    virtual void setBaseName( const std::string & basename );
 
  protected:
    Model( Model* parent = 0 );
    Model( const Model & m );
 
  private:
    Model  *_parent;
  };
 
 
  //    Fonctions inline
 
  inline Model::Model( Model* parent ) : _parent( parent )
  {
  }
 
 
  inline Model::Model( const Model & ) : _parent( 0 )
  {
  }
 
 
  inline Model & Model::operator = ( const Model & )
  {
    return( *this );
  }
 
 
  inline bool Model::isAdaptive() const
  {
    return( false );
  }
 
 
  inline bool Model::openFile( const std::string & )
  {
    return( false );
  }
 
 
  inline void Model::closeFile()
  {
  }
 
 
  inline void Model::subFiles( const std::string &,
                               std::set<std::string> & ) const
  {
  }
 
 
  inline Model* Model::parent()
  {
    return( _parent );
  }
 
 
  inline void Model::setParent( Model* m )
  {
    _parent = m;
  }
 
 
  inline TopModel* Model::topModel()
  {
    return( _parent ? _parent->topModel() : 0 );
  }
 
 
  inline const TopModel* Model::topModel() const
  {
    return( _parent ? _parent->topModel() : 0 );
  }
 
 
  inline carto::AttributedObject* Model::graphObject()
  {
    TopModel* tm = topModel();
    return tm ? tm->parentAO() : 0;
  }
 
 
  inline const carto::AttributedObject* Model::graphObject() const
  {
    const TopModel* tm = topModel();
    return tm ? tm->parentAO() : 0;
  }
 
 
  inline void Model::setBaseName( const std::string & )
  {
  }
 
 
  inline double Model::update( const Clique* cl, 
                               const std::map<Vertex*, std::string> & )
  {
    return update( cl );
  }
 
}
 
 
namespace carto
{
  DECLARE_GENERIC_OBJECT_TYPE( sigraph::Model * )
}
 
#endif