LogData.h

Go to the documentation of this file.

 
#ifndef LOGDATA_H
#define LOGDATA_H
 
#include <string>
#include <vector>
#include<stdio.h>
#include<stdlib.h>
#include "File.h"
#include "Timepp.h"
 
template<typename T>
class LogData {
public:
 
    //variables
    size_t num_samples; 
    size_t num_signals; 
    size_t max_num_samples; 
    std::vector<std::vector<T>> data; 
    std::vector<size_t> samples; 
    std::vector<std::string> signals; 
    std::string name; 
    std::string path; 
    std::string author; 
    Time* time; 
    int id = -1; 
    bool saved; 
    LogData(std::string str_name, std::string str_path, 
        std::vector<std::string> signal_names, int ID, 
        size_t num_of_signals, size_t num_of_samples, 
        Time* p_time = nullptr,  std::string theAuthor = "unknown") {
        name = str_name;
        path = str_path;
        saved = false;
        signals = signal_names;
        id = ID;
        time = p_time;
        author = theAuthor;
        num_samples = 0;
        max_num_samples = num_of_samples;
        num_signals = num_of_signals;
        data.resize(num_signals);
        for (int i = 0; i < num_signals; i++) data[i].reserve(max_num_samples);
        samples.reserve(max_num_samples);
    };
 
    ~LogData() {
        data.clear();
    };
 
    T get(int i, int j) { return data[i][j]; } //return data (i,j), i.e. one element (i-th signal and j-th sample)
    
    std::vector<T> get(int i) { return data[i]; } //return data(i,:), i.e. all samples of i-th signal
    
    int push_back(T* packet) { //append packet data to buffer
        if (num_samples > (max_num_samples - 1)) { return 0; } //return 0 if max_num_samples reached
        for (int i = 0; i < num_signals; ++i) data[i].push_back(packet[i]);
        samples.push_back(++num_samples);
        return num_signals;
    };
 
    std::string getAuthor() {
        return author;
    }
 
    std::string getDate() {
        if (time) {
            return time->getData(false);
        }
        else {
            return (std::string) "0000-00-00 00:00:00";
        }
    }
 
    size_t save(File* p_file) { //save to file, return the number of samples saved
        if (p_file == nullptr) { return 0; }
        T* buf = (T*)malloc(sizeof(T) * num_signals);
        if (buf == NULL) { free(buf);  return 0; }
        for (size_t j = 0; j < num_samples; ++j) {
            for (int i = 0; i < num_signals; ++i) buf[i] = get(i, j);
            if (num_signals * sizeof(T) != p_file->write((unsigned char*)buf, num_signals * sizeof(T))) {
                free(buf);
                return j;
            }
        }
        free(buf);
        saved = true;
        return num_samples;
    }
};
 
#endif