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