ArchiveMatch.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/ArchiveMatch.h
 
#ifndef __Pulsar_ArchiveMatch_h
#define __Pulsar_ArchiveMatch_h
 
#include "Pulsar/Archive.h"
#include "Pulsar/Config.h"
 
namespace Pulsar {

  class Archive::Match : public Reference::Able
  {
 
  public:

    Match ();

    virtual ~Match () {}

    virtual Match* clone () const;

    virtual bool match (const Archive* a, const Archive* b) const;

    std::string get_reason () const { return reason; }

    void set_check_mixable (bool flag = true);
    bool get_check_mixable () const;

    void set_check_standard (bool flag = true);
    bool get_check_standard () const;

    void set_check_calibrator (bool flag = true);
    bool get_check_calibrator () const;

    void set_check_processing (bool flag = true);
    bool get_check_processing () const;

    void set_check_state (bool flag = true);
    bool get_check_state () const;

    void set_check_type (bool flag = true);
    bool get_check_type () const;

    void set_check_source (bool flag = true);
    bool get_check_source () const;

    void set_check_scale (bool flag = true);
    bool get_check_scale () const;

    void set_check_faraday_corrected (bool flag = true);
    bool get_check_faraday_corrected () const;

    void set_check_dedispersed (bool flag = true);
    bool get_check_dedispersed () const;

    void set_check_nbin (bool flag = true);
    bool get_check_nbin () const;

    void set_check_nchan (bool flag = true);
    bool get_check_nchan () const;

    void set_check_npol (bool flag = true);
    bool get_check_npol () const;

    void set_check_receiver (bool flag = true);
    bool get_check_receiver () const;

    void set_check_centre_frequency (bool flag = true);
    bool get_check_centre_frequency () const;

    void set_check_bandwidth (bool flag = true);
    bool get_check_bandwidth () const;

    void set_check_bandwidth_sign (bool flag = true);
    bool get_check_bandwidth_sign () const;

    virtual bool get_bandwidth_match (const Archive* a, const Archive* b) const;

    static Option<double> max_frequency_difference;

    static Option<bool> opposite_sideband;

    static std::string separator;

    template <typename T>
    static Match* factory (T method)
    {
      Match* match = new Match;
      (match->*method) (true);
      return match;
    }
 
  protected:

    mutable std::string reason;
 
    bool check_state;
    bool check_type;
    bool check_source;
    bool check_scale;
    bool check_faraday_corrected;
    bool check_dedispersed;
    bool check_nbin;
    bool check_nchan;
    bool check_npol;
    bool check_receiver;
    bool check_centre_frequency;
    bool check_bandwidth;
    bool check_bandwidth_sign;
 
  };
 
}
 
#endif