BadSampleFilter.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
    Copyright 2016 UCAR, NCAR, All Rights Reserved
 ********************************************************************
*/
#ifndef NIDAS_CORE_BADSAMPLEFILTER_H
#define NIDAS_CORE_BADSAMPLEFILTER_H

#include <iosfwd>

#include "SampleTag.h"
#include <nidas/util/UTime.h>
#include "NidasApp.h"

namespace nidas { namespace core {

class BadSampleFilter
{
    typedef nidas::util::UTime UTime;

public:

    BadSampleFilter();

    void setFilterBadSamples(bool val);

    inline bool filterBadSamples() const
    {
        return _filterBadSamples;
    }

    void setMinDsmId(unsigned int val);

    unsigned int minDsmId() const
    {
        return _minDsmId;
    }

    void setMaxDsmId(unsigned int val);

    unsigned int maxDsmId() const
    {
        return _maxDsmId;
    }

    void setMinSampleLength(unsigned int val);

    unsigned int minSampleLength() const
    {
        return _minSampleLength;
    }

    void setMaxSampleLength(unsigned int val);

    unsigned int maxSampleLength() const
    {
        return _maxSampleLength;
    }
    
    void setMinSampleTime(const nidas::util::UTime& val);

    UTime minSampleTime() const
    {
        return _minSampleTime;
    }

    void setMaxSampleTime(const nidas::util::UTime& val);

    UTime maxSampleTime() const
    {
        return _maxSampleTime;
    }

    void setSkipNidasHeader(bool enable);

    bool
    skipNidasHeader() const
    {
        return _skipNidasHeader;
    }

    void
    setDefaultTimeRange(const UTime& start, const UTime& end);

    void
    setSampleTypeLimit(nidas::core::sampleType stype);

    nidas::core::sampleType
    sampleTypeLimit() const
    {
        return _sampleType;
    }

    void
    setRules(const std::string& rule);

    bool
    invalidSampleHeader(const SampleHeader& sheader);

    bool
    operator==(const BadSampleFilter& right) const;

private:
    
    void
    setRule(const std::string& rule);

    bool _filterBadSamples;

    unsigned int _minDsmId;
    unsigned int _maxDsmId;

    size_t _minSampleLength;
    size_t _maxSampleLength;

    dsm_time_t _minSampleTime;
    dsm_time_t _maxSampleTime;

    bool _skipNidasHeader;

    // Set the acceptable sample type.  Defaults to UNKNOWN_ST, meaning all
    // valid sample types are accepted.
    nidas::core::sampleType _sampleType;
};


std::ostream&
operator<<(std::ostream& out, const BadSampleFilter& bsf);


class BadSampleFilterArg : public nidas::core::NidasAppArg
{
public:
    BadSampleFilterArg();

    BadSampleFilter&
    getFilter()
    {
        return _bsf;
    }

    virtual bool
    parse(const ArgVector& argv, int* argi = 0);

private:
    BadSampleFilter _bsf;

};



}}  // namespace nidas namespace core

#endif  // NIDAS_CORE_BADSAMPLEFILTER_H