IntegrationManager.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/IntegrationManager.h
 
#ifndef __Pulsar_IntegrationManager_h
#define __Pulsar_IntegrationManager_h
 
#include "Pulsar/Container.h"
 
#include <algorithm>
 
namespace Pulsar {
 
  class Integration;
 
  bool temporal_order (const Reference::To<Integration>& A,
                       const Reference::To<Integration>& B);
 
 
  class IntegrationManager : public Container {
 
  public:
 
    static unsigned verbose;
 
    IntegrationManager ();
 
    IntegrationManager (const IntegrationManager& archive);
 
    IntegrationManager& operator = (const IntegrationManager& archive);
 
    virtual ~IntegrationManager ();
    
    Integration* get_Integration (unsigned subint);
 
    Integration* get_last_Integration ();
 
    Integration* get_first_Integration ();
    
    const Integration* get_Integration (unsigned subint) const;
    
    const Integration* get_last_Integration () const;
    
    const Integration* get_first_Integration () const;
    
    virtual Integration* new_Integration (const Integration* copy = 0) = 0;
 
    virtual Integration* use_Integration (Integration* use) = 0;
 
    virtual Integration* load_Integration (unsigned isubint) = 0;
 
 
    virtual unsigned get_nsubint () const = 0;
 
    template<class StrictWeakOrdering>
    void sort (StrictWeakOrdering comp = temporal_order)
    {
      load_all ();
      std::sort (subints.begin(), subints.begin()+get_nsubint(), comp);
    }
 
    void shuffle ();
      
    class Expert;
 
    Expert* expert ();
 
  protected:
 
    friend class TimeSortedOrder;
    friend class Expert;
 
 
    virtual void set_nsubint (unsigned num_sub) = 0;
 
    virtual void _resize (unsigned nsubint, bool instances=true);
 
    void append (const IntegrationManager* more_subints);
 
    void manage (IntegrationManager* more_subints);
 
    void manage (Integration* integration);
 
    void insert (unsigned isubint, Integration* integration);
 
    void unmanage (const Integration*);
 
    void unmanage (unsigned isubint);
 
    void load_all ();
 
  private:
 
 
    std::vector< Reference::To<Integration> > subints;
 
    Reference::To<Expert> expert_interface;
 
  };
 
}
 
#endif