Field.hpp

Go to the documentation of this file.

#ifndef COMSERVATORY_FIELD_HPP
#define COMSERVATORY_FIELD_HPP
 
#include <vector>
#include <string>
#include <complex>
#include <numeric>
#include "Type.hpp"
 
namespace comservatory {
 
struct Field {
    virtual ~Field() {}
    virtual size_t size() const = 0;
 
    virtual Type type() const = 0;
 
    virtual void add_missing() = 0;
 
    virtual bool filled() const { 
        return true;
    }
};
 
struct UnknownField : Field{
    size_t nrecords = 0;
    size_t size() const {
        return nrecords;
    }
 
    Type type() const {
        return UNKNOWN;
    }
 
    void add_missing() {
        ++nrecords;
        return;
    }
};
 
template<typename T, Type tt>
struct TypedField : public Field {
    Type type() const { return tt; }
 
    virtual void push_back(T x) = 0;
};
 
template<typename T, Type tt>
struct FilledField : public TypedField<T, tt> {
    FilledField(size_t n = 0) : missing(n), values(n) {
        if (n) {
            std::iota(missing.begin(), missing.end(), 0);
        }
    }
 
    std::vector<size_t> missing;
    std::vector<T> values;
    size_t size() const { 
        return values.size(); 
    }
 
    void push_back(T x) {
        values.emplace_back(std::move(x));
        return;
    }
 
    void add_missing() {
        size_t i = values.size();
        missing.push_back(i);
        values.resize(i + 1);
        return;
    }
};
 
template<typename T, Type tt>
struct DummyField : public TypedField<T, tt> {
    DummyField(size_t n = 0) : nrecords(n) {}
 
    size_t nrecords;
    size_t size() const {
        return nrecords;
    }
 
    void push_back(T) {
        ++nrecords;
        return;
    }
 
    void add_missing() {
        ++nrecords;
        return;
    }
 
    bool filled() const { 
        return false;
    }
};
 
typedef TypedField<std::string, STRING> StringField;
 
typedef FilledField<std::string, STRING> FilledStringField;
 
typedef DummyField<std::string, STRING> DummyStringField;
 
typedef TypedField<double, NUMBER> NumberField;
 
typedef FilledField<double, NUMBER> FilledNumberField;
 
typedef DummyField<double, NUMBER> DummyNumberField;
 
typedef TypedField<bool, BOOLEAN> BooleanField;
 
typedef FilledField<bool, BOOLEAN> FilledBooleanField;
 
typedef DummyField<bool, BOOLEAN> DummyBooleanField;
 
typedef TypedField<std::complex<double>, COMPLEX> ComplexField;
 
typedef FilledField<std::complex<double>, COMPLEX> FilledComplexField;
 
typedef DummyField<std::complex<double>, COMPLEX> DummyComplexField;
 
}
 
#endif