rcpp_shared_primitive.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_SHARED_PRIMITIVE_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_SHARED_PRIMITIVE_HPP
 
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
 
#include <Rcpp.h>
 
class SharedInt {
 private:
  std::shared_ptr<int> value;
 
 public:
  SharedInt() : value(std::make_shared<int>(0)) {}
 
  SharedInt(int val) : value(std::make_shared<int>(val)) {}
 
  SharedInt(const SharedInt& other) : value(other.value) {}
 
  SharedInt& operator=(const SharedInt& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }
 
  SharedInt& operator=(const int& other) {
    *value = other;
 
    return *this;
  }
 
  SharedInt(SharedInt&& other) noexcept : value(std::move(other.value)) {}
 
  SharedInt& operator=(SharedInt&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }
 
  // Access the value
 
  int get() const { return *value; }
 
  void set(int val) { *value = val; }
 
  operator int() { return this->get(); }
 
  // Overloaded operators for SharedPrimitive
 
  int operator*() const { return *value; }
 
  int* operator->() { return value.get(); }
 
  const int* operator->() const { return value.get(); }
 
  // Unary operators
 
  SharedInt& operator++() {
    ++(*value);
    return *this;
  }
 
  SharedInt operator++(int) {
    SharedInt temp(*this);
    ++(*value);
    return temp;
  }
 
  SharedInt& operator--() {
    --(*value);
    return *this;
  }
 
  SharedInt operator--(int) {
    SharedInt temp(*this);
    --(*value);
    return temp;
  }
 
  // Arithmetic operators with SharedPrimitive
 
  SharedInt operator+(const SharedInt& other) const {
    return SharedInt(*value + *other.value);
  }
 
  SharedInt operator-(const SharedInt& other) const {
    return SharedInt(*value - *other.value);
  }
 
  SharedInt operator*(const SharedInt& other) const {
    return SharedInt(*value * *other.value);
  }
 
  SharedInt operator/(const SharedInt& other) const {
    return SharedInt(*value / *other.value);
  }
 
  // Arithmetic operators with primitives
 
  SharedInt operator+(const int& other) const {
    return SharedInt(*value + other);
  }
 
  SharedInt operator-(const int& other) const {
    return SharedInt(*value - other);
  }
 
  SharedInt operator*(const int& other) const {
    return SharedInt(*value * other);
  }
 
  SharedInt operator/(const int& other) const {
    return SharedInt(*value / other);
  }
 
  // Compound assignment operators with SharedPrimitive
 
  SharedInt& operator+=(const SharedInt& other) {
    *value += *other.value;
    return *this;
  }
 
  SharedInt& operator-=(const SharedInt& other) {
    *value -= *other.value;
    return *this;
  }
 
  SharedInt& operator*=(const SharedInt& other) {
    *value *= *other.value;
    return *this;
  }
 
  SharedInt& operator/=(const SharedInt& other) {
    *value /= *other.value;
    return *this;
  }
 
  // Compound assignment operators with primitives
 
  SharedInt& operator+=(const int& other) {
    *value += other;
    return *this;
  }
 
  SharedInt& operator-=(const int& other) {
    *value -= other;
    return *this;
  }
 
  SharedInt& operator*=(const int& other) {
    *value *= other;
    return *this;
  }
 
  SharedInt& operator/=(const int& other) {
    *value /= other;
    return *this;
  }
 
  // Relational operators
 
  bool operator==(const SharedInt& other) const {
    return *value == *other.value;
  }
 
  bool operator!=(const SharedInt& other) const {
    return *value != *other.value;
  }
 
  bool operator<(const SharedInt& other) const { return *value < *other.value; }
 
  bool operator<=(const SharedInt& other) const {
    return *value <= *other.value;
  }
 
  bool operator>(const SharedInt& other) const { return *value > *other.value; }
 
  bool operator>=(const SharedInt& other) const {
    return *value >= *other.value;
  }
 
  // Relational operators with primitives
 
  bool operator==(const int& other) const { return *value == other; }
 
  bool operator!=(const int& other) const { return *value != other; }
 
  bool operator<(const int& other) const { return *value < other; }
 
  bool operator<=(const int& other) const { return *value <= other; }
 
  bool operator>(const int& other) const { return *value > other; }
 
  bool operator>=(const int& other) const { return *value >= other; }
 
  friend std::ostream& operator<<(std::ostream& os, const SharedInt& sp) {
    os << *sp.value;
    return os;
  }
};
 
// Non-member operators for primitive + SharedPrimitive
 
inline SharedInt operator+(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs + rhs.get());
}
 
inline SharedInt operator-(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs - rhs.get());
}
 
inline SharedInt operator*(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs * rhs.get());
}
 
inline SharedInt operator/(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs / rhs.get());
}
 
inline bool operator<(const int& lhs, const SharedInt& rhs) {
  return (lhs < rhs.get());
}
 
inline bool operator<=(const int& lhs, const SharedInt& rhs) {
  return (lhs <= rhs.get());
}
 
inline bool operator>(const int& lhs, const SharedInt& rhs) {
  return (lhs > rhs.get());
}
 
inline bool operator>=(const int& lhs, const SharedInt& rhs) {
  return (lhs >= rhs.get());
}
 
class SharedReal {
 private:
  std::shared_ptr<int> value;
 
 public:
  SharedReal() : value(std::make_shared<int>(0)) {}
 
  SharedReal(int val) : value(std::make_shared<int>(val)) {}
 
  SharedReal(const SharedReal& other) : value(other.value) {}
 
  SharedReal& operator=(const SharedReal& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }
 
  SharedReal& operator=(const int& other) {
    *value = other;
 
    return *this;
  }
 
  SharedReal(SharedReal&& other) noexcept : value(std::move(other.value)) {}
 
  SharedReal& operator=(SharedReal&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }
 
  int get() const { return *value; }
 
  void set(int val) { *value = val; }
 
  operator int() { return this->get(); }
 
  // Overloaded operators for SharedPrimitive
 
  int operator*() const { return *value; }
 
  int* operator->() { return value.get(); }
 
  const int* operator->() const { return value.get(); }
 
  // Unary operators
 
  SharedReal& operator++() {
    ++(*value);
    return *this;
  }
 
  SharedReal operator++(int) {
    SharedReal temp(*this);
    ++(*value);
    return temp;
  }
 
  SharedReal& operator--() {
    --(*value);
    return *this;
  }
 
  SharedReal operator--(int) {
    SharedReal temp(*this);
    --(*value);
    return temp;
  }
 
  // Arithmetic operators with SharedPrimitive
 
  SharedReal operator+(const SharedReal& other) const {
    return SharedReal(*value + *other.value);
  }
 
  SharedReal operator-(const SharedReal& other) const {
    return SharedReal(*value - *other.value);
  }
 
  SharedReal operator*(const SharedReal& other) const {
    return SharedReal(*value * *other.value);
  }
 
  SharedReal operator/(const SharedReal& other) const {
    return SharedReal(*value / *other.value);
  }
 
  // Arithmetic operators with primitives
 
  SharedReal operator+(const int& other) const {
    return SharedReal(*value + other);
  }
 
  SharedReal operator-(const int& other) const {
    return SharedReal(*value - other);
  }
 
  SharedReal operator*(const int& other) const {
    return SharedReal(*value * other);
  }
 
  SharedReal operator/(const int& other) const {
    return SharedReal(*value / other);
  }
 
  // Compound assignment operators with SharedPrimitive
 
  SharedReal& operator+=(const SharedReal& other) {
    *value += *other.value;
    return *this;
  }
 
  SharedReal& operator-=(const SharedReal& other) {
    *value -= *other.value;
    return *this;
  }
 
  SharedReal& operator*=(const SharedReal& other) {
    *value *= *other.value;
    return *this;
  }
 
  SharedReal& operator/=(const SharedReal& other) {
    *value /= *other.value;
    return *this;
  }
 
  SharedReal& operator+=(const int& other) {
    *value += other;
    return *this;
  }
 
  SharedReal& operator-=(const int& other) {
    *value -= other;
    return *this;
  }
 
  SharedReal& operator*=(const int& other) {
    *value *= other;
    return *this;
  }
 
  SharedReal& operator/=(const int& other) {
    *value /= other;
    return *this;
  }
 
  // Relational operators
 
  bool operator==(const SharedReal& other) const {
    return *value == *other.value;
  }
 
  bool operator!=(const SharedReal& other) const {
    return *value != *other.value;
  }
 
  bool operator<(const SharedReal& other) const {
    return *value < *other.value;
  }
 
  bool operator<=(const SharedReal& other) const {
    return *value <= *other.value;
  }
 
  bool operator>(const SharedReal& other) const {
    return *value > *other.value;
  }
 
  bool operator>=(const SharedReal& other) const {
    return *value >= *other.value;
  }
 
  // Relational operators with primitives
 
  bool operator==(const int& other) const { return *value == other; }
 
  bool operator!=(const int& other) const { return *value != other; }
 
  bool operator<(const int& other) const { return *value < other; }
 
  bool operator<=(const int& other) const { return *value <= other; }
 
  bool operator>(const int& other) const { return *value > other; }
 
  bool operator>=(const int& other) const { return *value >= other; }
 
  friend std::ostream& operator<<(std::ostream& os, const SharedReal& sp) {
    os << *sp.value;
    return os;
  }
};
 
inline SharedReal operator+(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs + rhs.get());
}
 
inline SharedReal operator-(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs - rhs.get());
}
 
inline SharedReal operator*(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs * rhs.get());
}
 
inline SharedReal operator/(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs / rhs.get());
}
 
class SharedString {
 private:
  std::shared_ptr<std::string> value;
 
 public:
  SharedString() : value(std::make_shared<std::string>()) {}
 
  SharedString(std::string val) : value(std::make_shared<std::string>(val)) {}
 
  SharedString(const SharedString& other) : value(other.value) {}
 
  SharedString& operator=(const SharedString& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }
 
  SharedString& operator=(const std::string& other) {
    *value = other;
    return *this;
  }
 
  SharedString(SharedString&& other) noexcept : value(std::move(other.value)) {}
 
  SharedString& operator=(SharedString&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }
 
  std::string get() const { return *value; }
 
  void set(std::string val) { *value = val; }
 
  operator std::string() { return this->get(); }
 
  std::string operator*() const { return *value; }
 
  std::string* operator->() { return value.get(); }
 
  const std::string* operator->() const { return value.get(); }
 
  friend std::ostream& operator<<(std::ostream& os, const SharedString& sp) {
    os << *sp.value;
    return os;
  }
};
 
class SharedBoolean {
 private:
  std::shared_ptr<bool> value;
 
 public:
  SharedBoolean() : value(std::make_shared<bool>(0)) {}
 
  SharedBoolean(bool val) : value(std::make_shared<bool>(val)) {}
 
  SharedBoolean(const SharedBoolean& other) : value(other.value) {}
 
  SharedBoolean& operator=(const SharedBoolean& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }
 
  SharedBoolean& operator=(const bool& other) {
    *value = other;
    return *this;
  }
 
  SharedBoolean(SharedBoolean&& other) noexcept
      : value(std::move(other.value)) {}
 
  SharedBoolean& operator=(SharedBoolean&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }
 
  bool get() const { return *value; }
 
  void set(bool val) { *value = val; }
 
  operator bool() { return this->get(); }
 
  bool operator*() const { return *value; }
 
  bool* operator->() { return value.get(); }
 
  const bool* operator->() const { return value.get(); }
 
  bool operator==(const SharedBoolean& other) const {
    return *value == *other.value;
  }
 
  bool operator!=(const SharedBoolean& other) const {
    return *value != *other.value;
  }
 
  bool operator<(const SharedBoolean& other) const {
    return *value < *other.value;
  }
 
  bool operator<=(const SharedBoolean& other) const {
    return *value <= *other.value;
  }
 
  bool operator>(const SharedBoolean& other) const {
    return *value > *other.value;
  }
 
  bool operator>=(const SharedBoolean& other) const {
    return *value >= *other.value;
  }
 
  bool operator==(const bool& other) const { return *value == other; }
 
  bool operator!=(const bool& other) const { return *value != other; }
 
  bool operator<(const bool& other) const { return *value < other; }
 
  bool operator<=(const bool& other) const { return *value <= other; }
 
  bool operator>(const bool& other) const { return *value > other; }
 
  bool operator>=(const bool& other) const { return *value >= other; }
 
  friend std::ostream& operator<<(std::ostream& os, const SharedBoolean& sp) {
    os << *sp.value;
    return os;
  }
};
 
inline bool operator<(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs < rhs.get());
}
 
inline bool operator<=(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs <= rhs.get());
}
 
inline bool operator>(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs > rhs.get());
}
 
inline bool operator>=(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs >= rhs.get());
}
 
typedef SharedInt fims_int;
typedef SharedReal fims_double;
typedef SharedString fims_string;
typedef SharedBoolean fims_bool;
 
RCPP_EXPOSED_CLASS(SharedInt)
RCPP_EXPOSED_CLASS(SharedString)
RCPP_EXPOSED_CLASS(SharedReal)
RCPP_EXPOSED_CLASS(SharedBoolean)
 
#endif