Composite.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/MEAL/MEAL/Composite.h
 
#ifndef __Composite_H
#define __Composite_H
 
#include "MEAL/Function.h"
#include "MEAL/Projection.h"
 
namespace MEAL {

  class Composite : public ParameterPolicy {
 
  public:

    Composite (Function* context);

    Composite* clone (Function* context) const { return 0; }

    unsigned get_nmodel () const;

    std::string class_name() const;
 
    // ///////////////////////////////////////////////////////////////////
    //
    // ParameterPolicy implementation
    //
    // ///////////////////////////////////////////////////////////////////
 
    unsigned get_nparam () const;

    std::string get_name (unsigned index) const;

    std::string get_description (unsigned index) const;

    double get_param (unsigned index) const;

    void set_param (unsigned index, double value);

    double get_variance (unsigned index) const;

    void set_variance (unsigned index, double variance);

    bool get_infit (unsigned index) const;

    void set_infit (unsigned index, bool flag);
 
    // ///////////////////////////////////////////////////////////////////
    //
    // ArgumentPolicy implementation
    //
    // ///////////////////////////////////////////////////////////////////

    void set_argument (unsigned dimension, Argument* axis);

    template <class Type>
    void map (Project<Type>& model)
    {
      if (Function::very_verbose)
        std::cerr << class_name() + "map (Project<Type>)" << std::endl;
      map (model.get_map());
    }

    template <class Type>
    void unmap (Project<Type>& model)
    {
      if (Function::very_verbose)
        std::cerr << class_name() + "unmap (Project<Type>)" << std::endl;
      unmap (model.get_map());
    }

    void map (Projection* model);

    void unmap (Projection* model);

    void clear ();
    
    void get_imap (const Function* model,
                   std::vector<unsigned>::iterator& imap) const;

    void attribute_changed (Function::Attribute attribute);
 
  protected:

    friend class Projection;

    unsigned find_Function (Function* model) const;

    unsigned find_Projection (Projection* model) const;
 
  private:

    std::vector< Reference::To<Projection> > maps;

    std::vector< Reference::To<Function> > models;
    
    mutable unsigned nparameters;
    
    mutable unsigned current_model;

    mutable unsigned current_index;

    mutable bool remap_needed;

    mutable bool disable_callbacks;

    mutable bool component_shares_this;

    void init ();

    void add_component (Function*, std::vector<unsigned>& imap);

    void remove_component (Function*);

    void remap ();

    void remap_later ();

    void callbacks ();

    void recount () const;

    const Function* get_Function (unsigned& index) const;

    Function* get_Function (unsigned& index);

    void reference_check (unsigned imodel, const char* method) const;
 
  };
 
  void get_imap (const Function* composite, const Function* component,
                 std::vector<unsigned>& imap);
 
}
 
 
#endif