src/libstfio/recording.h

Go to the documentation of this file.

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

#ifndef _RECORDING_H
#define _RECORDING_H

// #include "./channel.h"
// #include "./section.h"
// #include "./stfio.h"

class Channel;
class Section;


class StfioDll Recording {
 public:

    //ctor/dtor-------------------------------------------------------
    explicit Recording();


    explicit Recording(const Channel& c_Channel); 


    explicit Recording(const std::vector<Channel>& ChannelList); 


    explicit Recording( std::size_t c_n_channels, std::size_t c_n_sections = 0, std::size_t c_n_points = 0 );

    virtual ~Recording();

    //member access functions: read-----------------------------------
    

    std::size_t GetChannelSize(std::size_t n_channel) const;


    const std::vector<Channel>& get() const { return ChannelArray; }
    

    std::vector<Channel>& get() { return ChannelArray; }
    

    const std::string& GetFileDescription() const { return file_description; }


    const std::string& GetGlobalSectionDescription() const { return global_section_description; }


    const std::string& GetScaling() const { return scaling; }


    const std::string& GetTime() const { return time; }


    const std::string& GetDate() const { return date; }


    const std::string& GetComment() const { return comment; }
    

    const std::string& GetXUnits() const { return xunits; }


    std::size_t size() const { return ChannelArray.size(); }
    

    double GetXScale() const { return dt; }
    

    double GetSR() const { return 1.0/dt; }


    const Channel& at(std::size_t n_c) const;


    Channel& at(std::size_t n_c);

    //member access functions: write---------------------------------


    void SetFileDescription(const std::string& value) { file_description=value; }


    void SetGlobalSectionDescription(const std::string& value) {
        global_section_description=value;
    }


    void SetScaling(const std::string& value) { scaling=value; }
 

    void SetTime(const std::string& value) { time=value; }


    void SetDate(const std::string& value) { date=value; }


    void SetComment(const std::string& value) { comment=value; }
    

    void SetGlobalYUnits(std::size_t n_channel, const std::string& value);


    void SetXUnits(const std::string& value) { xunits=value; }


    void SetXScale(double value);
    
    //misc-----------------------------------------------------------


    virtual void resize(std::size_t c_n_channels);


    virtual void InsertChannel(Channel& c_Channel, std::size_t pos);


    void CopyAttributes(const Recording& c_Recording);


    void MakeAverage( Section& AverageReturn, Section& SigReturn, std::size_t channel,
                      const std::vector<std::size_t>& section_index, bool isSig,
                      const std::vector<int>& shift) const;


    void AddRec(const Recording& toAdd);
    
    //operators------------------------------------------------------


    Channel& operator[](std::size_t at) { return ChannelArray[at]; }


    const Channel& operator[](std::size_t at) const { return ChannelArray[at]; }

 private:
    std::vector<Channel> ChannelArray;
    std::string global_section_description, scaling;

    /* public: */
    
    double dt;
    std::string file_description, time, date, comment, xunits;

    void init();

};

#endif