Nullable.h

Go to the documentation of this file.

 
// Nullable.h: Rcpp R/C++ interface class library -- SEXP container which can be NULL
//
// Copyright (C) 2015-2026  Dirk Eddelbuettel and Daniel C. Dillon
//
// This file is part of Rcpp.
//
// Rcpp is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Rcpp is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef Rcpp_Nullable_h
#define Rcpp_Nullable_h
 
// We looked into the safe_bool_idiom [1] but found that more trouble than is
// warranted here.  We first and foremost want an operator SEXP() which got in
// the way of redefining operator bool.
// [1] http://www.artima.com/cppsource/safebool.html)
 
namespace Rcpp {
 
    template<class T>
    class Nullable {
    public:

        inline Nullable() : m_sexp(R_NilValue), m_set(false) {}

 
        inline Nullable(const T &t) : m_sexp(t),  m_set(true) {}

        inline Nullable(SEXP t) {
            m_sexp = t;
            m_set = true;
        }
 
    public:

        inline Nullable &operator=(SEXP sexp) {
            m_sexp = sexp;
            m_set = true;
            return *this;
        }

        inline operator SEXP() const {
            checkIfSet();
            return m_sexp;
        }
 
#if R_VERSION > R_Version(4,3,0) && !defined(RCPP_DISABLE_NULLABLE_T)
        inline operator T() const {
            checkIfSet();
            return Rcpp::as<T>(m_sexp);
        }
#endif

        inline SEXP get() const {
            checkIfSet();
            return m_sexp;
        }

        inline bool isUsable() const {
            return m_set && !Rf_isNull(m_sexp);
        }

        inline bool isNull() const {
            checkIfSet();
            return Rf_isNull(m_sexp);
        }

        inline bool isNotNull() const {
            return ! isNull();
        }

        inline bool isSet(void) const { return m_set; }

        inline T as() { return Rcpp::as<T>(get()); }

        inline T clone() const { return Rcpp::clone(get()); }
 
    private:
        SEXP m_sexp;
        bool m_set;
 
        inline void checkIfSet(void) const {
            if (!m_set) {
                throw ::Rcpp::exception("Not initialized");
            }
        }
    };
}
 
#endif