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 <optional>
 
#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 final : public RObject {
    SEXPType type() const { return SEXPType::NIL; }
};
 
struct Symbol {
    Symbol() = default;
 
    Symbol(std::string name, StringEncoding encoding) : name(std::move(name)), encoding(encoding) {}
 
    std::string name;
 
    StringEncoding encoding = StringEncoding::UTF8;
};
 
struct SymbolIndex final : public RObject {
    SymbolIndex() = default;
 
    SymbolIndex(std::size_t i) : index(i) {}
 
 
    SEXPType type() const { return SEXPType::SYM; }
 
    std::size_t index = - 1;
};
 
inline SymbolIndex register_symbol(std::string name, StringEncoding encoding, std::vector<Symbol>& symbols) {
    auto idx = symbols.size();
    symbols.emplace_back(std::move(name), encoding);
    return SymbolIndex(idx);
}
 
struct Attribute;
struct EnvironmentIndex final : public RObject {
    EnvironmentIndex() = default;
 
    EnvironmentIndex(SEXPType e) : env_type(e) {}
 
    EnvironmentIndex(std::size_t i): index(i), env_type(SEXPType::ENV) {}
 
    SEXPType type() const { return env_type; }
 
    std::size_t index = -1;
 
    SEXPType env_type = SEXPType::GLOBALENV_;
};
 
struct EnvironmentVariable {
    EnvironmentVariable() = default;
 
    EnvironmentVariable(SymbolIndex name, std::unique_ptr<RObject> value) : name(std::move(name)), value(std::move(value)) {}
 
    SymbolIndex name;
    std::unique_ptr<RObject> value;
};
 
struct Environment {
    bool locked = false;
 
    bool hashed = false;
 
    SEXPType parent_type = SEXPType::GLOBALENV_;
 
    std::size_t parent = -1;
 
    std::vector<EnvironmentVariable> variables;
 
    std::vector<Attribute> attributes;
};
 
struct ExternalPointer {
    std::unique_ptr<RObject> protection;
 
    std::unique_ptr<RObject> tag;
 
    std::vector<Attribute> attributes;
};
 
struct ExternalPointerIndex final : public RObject {
    ExternalPointerIndex() = default;
 
    ExternalPointerIndex(std::size_t i) : index(i) {}
 
 
    SEXPType type() const { return SEXPType::EXTPTR; }
 
    std::size_t index = -1;
};
 
struct Attribute {
    Attribute() = default;
 
    Attribute(SymbolIndex name, std::unique_ptr<RObject> value) : name(std::move(name)), value(std::move(value)) {}
 
    SymbolIndex name;
 
    std::unique_ptr<RObject> value;
};
 
template<typename ElementType, SEXPType stype>
struct AtomicVector final : 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;
 
    std::vector<Attribute> 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 String {
    String() = default;
 
    String(std::string value, StringEncoding encoding) : value(std::move(value)), encoding(encoding) {}
 
    std::optional<std::string> value;
 
    StringEncoding encoding = StringEncoding::UTF8;
};
 
struct StringVector final : public RObject {
    StringVector(std::size_t n = 0) : data(sanisizer::cast<I<decltype(data.size())> >(n)) {}
    SEXPType type() const { return SEXPType::STR; }
 
    std::vector<String> data;
 
    std::vector<Attribute> attributes;
};
 
struct GenericVector final : 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;
 
    std::vector<Attribute> attributes;
};
 
struct PairListElement {
    PairListElement() = default;
 
    PairListElement(std::unique_ptr<RObject> value) : value(std::move(value)) {}
 
    PairListElement(SymbolIndex tag, std::unique_ptr<RObject> value) : tag(std::move(tag)), value(std::move(value)) {}
 
    std::optional<SymbolIndex> tag;
 
    std::unique_ptr<RObject> value;
};
 
struct PairList final : public RObject {
    SEXPType type() const { return SEXPType::LIST; }
 
    std::vector<PairListElement> data; 
 
    std::vector<Attribute> attributes;
};
 
struct S4Object final : 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;
 
    std::vector<Attribute> attributes;
};
 
struct BuiltInFunction final : public RObject {
    SEXPType type() const { return SEXPType::BUILTIN; }
 
    std::string name;
};
 
struct LanguageArgument {
    LanguageArgument() = default;
 
    LanguageArgument(SymbolIndex name, std::unique_ptr<RObject> value) : name(std::move(name)), value(std::move(value)) {}
 
    LanguageArgument(std::unique_ptr<RObject> value) : value(std::move(value)) {}
 
    std::optional<SymbolIndex> name;
 
    std::unique_ptr<RObject> value;
};
 
struct LanguageObject final : public RObject {
 
    SEXPType type() const { return SEXPType::LANG; }
 
    SymbolIndex function;
 
    std::vector<LanguageArgument> arguments;
 
    std::vector<Attribute> attributes;
};
 
struct ExpressionVector final : 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;
 
    std::vector<Attribute> attributes;
};
 
}
 
#endif