matlogger2.h

Go to the documentation of this file.

#ifndef __XBOT_MATLOGGER2_H__
#define __XBOT_MATLOGGER2_H__

#include <string>
#include <memory>
#include <unordered_map>

#include <eigen3/Eigen/Dense>

#include <matlogger2/utils/var_buffer.h>



namespace XBot 
{
    namespace matlogger2 
    {
        class Backend;
    }

    class MatLogger2 
    {
        
    public:
        
        
        typedef std::weak_ptr<MatLogger2> WeakPtr;
        typedef std::shared_ptr<MatLogger2> Ptr;
        
        struct Options
        {
            bool enable_compression;
            int default_buffer_size;
            
            Options();
        };
        
        template <typename... Args>
        static Ptr MakeLogger(Args... args);
        
        const std::string& get_filename() const;
        
        Options get_options() const;
        
        void set_on_data_available_callback(VariableBuffer::CallbackType callback);
        
        void set_buffer_mode(VariableBuffer::Mode buffer_mode);
    
        bool create(const std::string& var_name, 
                    int rows, int cols = 1, 
                    int buffer_size = -1);
        
        
        template <typename Derived>
        bool add(const std::string& var_name, const Eigen::MatrixBase<Derived>& data);
        
        template <typename Scalar>
        bool add(const std::string& var_name, const std::vector<Scalar>& data);
        
        template <typename Iterator>
        // this overload may allocate a temporary vector!
        bool add(const std::string& var_name, Iterator begin, Iterator end);
        
        bool add(const std::string& var_name, double data);
        
        int flush_available_data();
        
        ~MatLogger2();
        
    private:
        
        MatLogger2(std::string file, 
                   Options opt = Options());
        
        bool flush_to_queue_all();
        
        VariableBuffer * find_or_create(const std::string& var_name,    
                                        int rows, int cols
                                        );
        
        
        // option struct
        Options _opt;
        
        // protect non-const access to _vars
        // producer must hold it during create(), and 
        // set_on_data_available_callback()
        // consumer must hold it during flush_available_data()
        class MutexImpl;
        std::unique_ptr<MutexImpl> _vars_mutex;
        
        // map of all defined variables 
        std::unordered_map<std::string, VariableBuffer> _vars;
        
        // buffer mode
        VariableBuffer::Mode _buffer_mode;
        
        // callback that all variables shall use to notify that a new block is available 
        VariableBuffer::CallbackType _on_block_available;
        
        // path to mat-file
        std::string _file_name;
        
        // handle to backend object
        std::unique_ptr<matlogger2::Backend> _backend;
        
        
    };
    


}

template <typename... Args>
inline XBot::MatLogger2::Ptr XBot::MatLogger2::MakeLogger(Args... args)
{
    return Ptr(new MatLogger2(args...));
}
        
template <typename Derived>
inline bool XBot::MatLogger2::add(const std::string& var_name, const Eigen::MatrixBase< Derived >& data)
{
    VariableBuffer * vbuf = find_or_create(var_name, data.rows(), data.cols());
    
    return vbuf && vbuf->add_elem(data);
    
}

template<typename Iterator> 
inline bool XBot::MatLogger2::add(const std::string& var_name, Iterator begin, Iterator end)
{
    static std::vector<double> tmp;
    tmp.clear();
    tmp.assign(begin, end);
    
    return add(var_name, tmp);
    
}


template <typename Scalar>
inline bool XBot::MatLogger2::add(const std::string& var_name, const std::vector<Scalar>& data)
{
    Eigen::Map<const Eigen::Matrix<Scalar,-1,1>> map(data.data(), data.size());
    return add(var_name, map);
}


#endif