src/base/chan_list.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef SENDS_CHAN_LIST_HH
#define SENDS_CHAN_LIST_HH
#include <string>
#include <vector>
#include <iosfwd>

namespace sends {

    class chan_entry {
    public:

        enum chan_type {
            kUnknown,
            kOnline,
            kRawData,
            kReduced,
            kSecondTrend,
            kMinuteTrend,
            kTypeCount     // Number of data types
        };

        enum data_type {
            kByte1,
            kInt2,
            kInt4,
            kInt8,
            kReal4,
            kReal8,
            kComplex8,
            kComplex16     // Number of data types
        };

        typedef unsigned long source_count;

        typedef unsigned long gps_type;

    public:
        chan_entry(const std::string& name, chan_type type, long access=0, 
                   data_type dtype=kReal4, double rate=0,
                   const std::string& source="");

        void addSource(const std::string& ftype);

        bool available(gps_type t) const;

        long getAccess(void) const {return mAccess;}

        data_type dtype(void) const {return mDType;}

        int data_size(void) const {return getDataSize(mDType);}

        static data_type getDataCode(const std::string& str);

        static int getDataSize(data_type type);

        static std::string getDataString(data_type type);

        const std::string& name(void) const {return mName;}

        source_count getNSource(void) const;

        const std::string& getSource(source_count inx=0) const;

        chan_type type(void) const {return mType;}

        static chan_type getTypeCode(const std::string& str);

        static std::string getTypeString(chan_type type);

        bool is_source(const std::string& src) const;

        void merge(const chan_entry& ce);

        bool operator<(const chan_entry& ent)  const;

        bool operator==(const chan_entry& ent) const;

        bool operator!=(const chan_entry& ent) const;

        double rate(void) const;

    private:
        typedef std::vector<std::string>    source_vect;
        typedef source_vect::iterator       source_iter;
        typedef source_vect::const_iterator const_source_iter;
    private:
        std::string mName;
        chan_type   mType;
        long        mAccess;
        data_type   mDType;
        double      mRate;
        source_vect mSource;
    };

    std::ostream& operator<<(std::ostream& out, const chan_entry& ent);

    class chan_list {
    public:
        typedef unsigned long chan_index;
    public:
        chan_list(unsigned long ndef=100000);

        chan_index add_channel(const chan_entry& ce);

        void clear(void);

        std::ostream& dump(std::ostream& out) const;

        void enable(void);

        chan_index find(const std::string& name, chan_entry::chan_type t) const;

        chan_index find(const chan_entry& ent) const;

        chan_index find_best(const std::string& name, chan_entry::chan_type t,
                             double rate, chan_entry::gps_type gps) const;

        chan_index lower_bound(const chan_entry& ent) const;

        void read(const std::string& file);

        void reserve(chan_index nMax);

        chan_index size(void) const;

        const chan_entry& operator[](chan_index inx) const;
    private:
        typedef std::vector<chan_entry> chan_vect;
        
    private:
        bool list_available;
        chan_vect mChanList;
    };


    //==================================  Define inline methods
    inline chan_entry::source_count 
    chan_entry::getNSource(void) const {
        return mSource.size();
    }

    inline const std::string& 
    chan_entry::getSource(source_count inx) const {
        return mSource[inx];
    }

    inline bool 
    chan_entry::operator<(const chan_entry& ent) const {
        return (mName < ent.mName) ||
               (mName == ent.mName && mType < ent.mType);
    }

    inline bool 
    chan_entry::operator==(const chan_entry& ent) const {
        return (mName == ent.mName && mType == ent.mType);
    }

    inline bool 
    chan_entry::operator!=(const chan_entry& ent) const {
        return (mName != ent.mName || mType != ent.mType);
    }

    inline double
    chan_entry::rate(void) const {
        return mRate;
    }

    inline chan_list::chan_index 
    chan_list::size(void) const {
        return mChanList.size();
    }

} // namespace sends

#endif // !defined(SENDS_CHAN_LIST_HH)

---