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