RObject.hpp

Go to the documentation of this file.

#ifndef RDS2CPP_ROBJECT_HPP
#define RDS2CPP_ROBJECT_HPP
 
#include <vector>
#include <cstdint>
#include <cstddef>
#include <complex>
 
#include "SEXPType.hpp"
#include "StringEncoding.hpp"
#include "utils_other.hpp"
 
#include "sanisizer/sanisizer.hpp"
 
namespace rds2cpp {
 
struct RObject {
    RObject() {}
    virtual ~RObject() {}
 
    // Rule of 5'ing.
    RObject& operator=(const RObject& rhs) = default;
    RObject(const RObject& rhs) = default;
    RObject& operator=(RObject&& rhs) = default;
    RObject(RObject&& rhs) = default;
    virtual SEXPType type() const = 0;
};
 
struct Null : public RObject {
    SEXPType type() const { return SEXPType::NIL; }
};
 
struct SymbolIndex : public RObject {
    SymbolIndex(std::size_t i = -1) : index(i) {}
 
 
    SEXPType type() const { return SEXPType::SYM; }
 
    std::size_t index;
};
 
struct EnvironmentIndex : public RObject {
    EnvironmentIndex(SEXPType e = SEXPType::GLOBALENV_) : index(-1), env_type(e) {}
 
    EnvironmentIndex(std::size_t i): index(i), env_type(SEXPType::ENV) {}
 
    SEXPType type() const { return env_type; }
 
    std::size_t index;
 
    SEXPType env_type;
};
 
struct ExternalPointerIndex : public RObject {
    ExternalPointerIndex(std::size_t i = -1) : index(i) {}
 
 
    SEXPType type() const { return SEXPType::EXTPTR; }
 
    std::size_t index;
};
 
struct Attributes {
    std::vector<std::string> names;
 
    std::vector<StringEncoding> encodings;
 
    std::vector<std::unique_ptr<RObject> > values;
 
    void add(std::string n, RObject* v, StringEncoding enc = StringEncoding::UTF8) {
        names.emplace_back(std::move(n));
        encodings.emplace_back(enc);
        values.emplace_back(v);
    }
 
    void add(std::string n, std::unique_ptr<RObject> v, StringEncoding enc = StringEncoding::UTF8) {
        names.emplace_back(std::move(n));
        encodings.emplace_back(enc);
        values.emplace_back(std::move(v));
    }
};
 
template<typename ElementType, SEXPType stype>
struct AtomicVector : public RObject {
    AtomicVector(std::size_t n = 0) :
        data(sanisizer::cast<I<decltype(data.size())> >(n))
    {}
 
    static constexpr SEXPType vector_sexp_type = stype;
    SEXPType type() const { return stype; }
 
    std::vector<ElementType> data;
 
    Attributes attributes;
};
 
typedef AtomicVector<std::int32_t, SEXPType::INT> IntegerVector;
 
typedef AtomicVector<std::int32_t, SEXPType::LGL> LogicalVector;
 
typedef AtomicVector<double, SEXPType::REAL> DoubleVector;
 
typedef AtomicVector<unsigned char, SEXPType::RAW> RawVector;
 
typedef AtomicVector<std::complex<double>, SEXPType::CPLX> ComplexVector;
 
struct StringVector : public RObject {
    StringVector(std::size_t n = 0) :
        data(sanisizer::cast<I<decltype(data.size())> >(n)),
        encodings(sanisizer::cast<I<decltype(encodings.size())> >(n)),
        missing(sanisizer::cast<I<decltype(missing.size())> >(n))
    {}
    SEXPType type() const { return SEXPType::STR; }
 
    std::vector<std::string> data;
 
    std::vector<StringEncoding> encodings;
 
    std::vector<char> missing;
 
    void add(std::string d, StringEncoding enc = StringEncoding::UTF8) {
        data.push_back(std::move(d));
        encodings.push_back(enc);
        missing.push_back(false);
    }
 
    void add() {
        data.push_back("");
        encodings.push_back(StringEncoding::NONE);
        missing.push_back(true);
    }
 
    Attributes attributes;
};
 
struct GenericVector : public RObject {
    GenericVector(std::size_t n = 0) :
        data(sanisizer::cast<I<decltype(data.size())> >(n))
    {}
    SEXPType type() const { return SEXPType::VEC; } 
 
    std::vector<std::unique_ptr<RObject> > data;
 
    Attributes attributes;
};
 
struct PairList : public RObject {
    SEXPType type() const { return SEXPType::LIST; }
 
    std::vector<std::unique_ptr<RObject> > data; 
 
    std::vector<unsigned char> has_tag;
 
    std::vector<std::string> tag_names;
 
    std::vector<StringEncoding> tag_encodings;
 
    void add(std::string t, std::unique_ptr<RObject> d, StringEncoding enc = StringEncoding::UTF8) {
        data.push_back(std::move(d));
        has_tag.push_back(true);
        tag_names.push_back(std::move(t));
        tag_encodings.push_back(enc);
    }
 
    void add(std::string t, RObject* d, StringEncoding enc = StringEncoding::UTF8) {
        data.emplace_back(d);
        has_tag.push_back(true);
        tag_names.push_back(std::move(t));
        tag_encodings.push_back(enc);
    }
 
    void add(std::unique_ptr<RObject> d) {
        data.push_back(std::move(d));
        has_tag.push_back(false);
        tag_names.push_back("");
        tag_encodings.push_back(StringEncoding::NONE);
    }
 
    void add(RObject* d) {
        data.emplace_back(d);
        has_tag.push_back(false);
        tag_names.push_back("");
        tag_encodings.push_back(StringEncoding::NONE);
    }
 
    Attributes attributes;
};
 
struct S4Object : public RObject {
    SEXPType type() const { return SEXPType::S4; }
 
    std::string class_name;
 
    StringEncoding class_encoding = StringEncoding::UTF8;
 
    std::string package_name;
 
    StringEncoding package_encoding = StringEncoding::UTF8;
 
    Attributes attributes;
};
 
struct BuiltInFunction : public RObject {
    SEXPType type() const { return SEXPType::BUILTIN; }
 
    std::string name;
};
 
struct LanguageObject : public RObject {
 
    SEXPType type() const { return SEXPType::LANG; }
 
    std::string function_name;
 
    StringEncoding function_encoding = StringEncoding::UTF8;
 
    std::vector<std::unique_ptr<RObject> > argument_values;
 
    std::vector<std::string> argument_names;
 
    std::vector<unsigned char> argument_has_name;
 
    std::vector<StringEncoding> argument_encodings;
 
    void add_argument(std::string n, RObject* d, StringEncoding enc = StringEncoding::UTF8) {
        argument_names.push_back(std::move(n));
        argument_values.emplace_back(d);
        argument_has_name.push_back(true);
        argument_encodings.push_back(enc);
    }
 
    void add_argument(std::string n, std::unique_ptr<RObject> d, StringEncoding enc = StringEncoding::UTF8) {
        argument_names.push_back(std::move(n));
        argument_values.push_back(std::move(d));
        argument_has_name.push_back(true);
        argument_encodings.push_back(enc);
    }
 
    void add_argument(RObject* d) {
        argument_names.emplace_back();
        argument_values.emplace_back(d);
        argument_has_name.push_back(false);
        argument_encodings.push_back(StringEncoding::NONE);
    }
 
    void add_argument(std::unique_ptr<RObject> d) {
        argument_names.emplace_back();
        argument_values.push_back(std::move(d));
        argument_has_name.push_back(false);
        argument_encodings.push_back(StringEncoding::NONE);
    }
 
    Attributes attributes;
};
 
struct ExpressionVector : public RObject {
    ExpressionVector(std::size_t n = 0) :
        data(sanisizer::cast<I<decltype(data.size())> >(n))
    {}
    SEXPType type() const { return SEXPType::EXPR; }
 
    std::vector<std::unique_ptr<RObject> > data;
 
    Attributes attributes;
};
 
}
 
#endif