src/base/frame_loc.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef SENDS_FRAME_LOC_HH
#define SENDS_FRAME_LOC_HH

#include <string>
#include <iosfwd>

namespace sends {

    class frame_loc {
    public:

        typedef unsigned long gps_type;

        enum arch_type {
            kOnline,
            kCache,
            kArchive,
            kOffline
        };

        enum driver_type {
            kLocal,
            kSamQfs,
            kSends,
            kShared,
            kUnknown  // kUnknown must be the last type
        };
    public:
        frame_loc(const std::string& location, const std::string& prefix, 
                  gps_type start, gps_type stop, gps_type dT, 
                  arch_type type, driver_type driv=kUnknown);

        ~frame_loc(void);

        arch_type archive(void) const;

        driver_type driver(void) const;

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

        gps_type frame_end(gps_type t) const;

        std::string frame_path(gps_type gps) const;

        gps_type frame_start(gps_type t) const;

        gps_type gps_end(void) const;

        gps_type gps_start(void) const;

        bool in_range(gps_type gps) const;

        const std::string& prefix(void) const;

        gps_type start(void) const;

        gps_type stop(void) const;

    private:
        std::string mLocation;
        std::string mPrefix;
        gps_type    mStart;
        gps_type    mStop;
        gps_type    mDuration;
        arch_type   mType;
        driver_type mDriver;
    };

    //==================================  Inline methods
    inline frame_loc::arch_type 
    frame_loc::archive(void) const {
        return mType;
    }

    inline frame_loc::driver_type 
    frame_loc::driver(void) const {
        return mDriver;
    }

    inline frame_loc::gps_type 
    frame_loc::frame_end(gps_type t) const {
        gps_type end = frame_start(t) + mDuration;
        if (end > mStop) end = mStop;
        return end;
    }

    inline frame_loc::gps_type 
    frame_loc::frame_start(gps_type t) const {
        return t - (t - mStart)%mDuration;
    }

    inline frame_loc::gps_type 
    frame_loc::gps_end(void) const {
        return mStop;
    }

    inline frame_loc::gps_type 
    frame_loc::gps_start(void) const {
        return mStart;
    }

    inline bool
    frame_loc::in_range(gps_type gps) const {
        return gps >= mStart && gps < mStop;
    }

    inline const std::string& 
    frame_loc::prefix(void) const {
        return mPrefix;
    }

    inline frame_loc::gps_type 
    frame_loc::start(void) const {
        return mStart;
    }

    inline frame_loc::gps_type 
    frame_loc::stop(void) const {
        return mStop;
    }

} // namespace sends

#endif  // !defined(SENDS_FRAME_LOC_HH)

---