optional.h

Go to the documentation of this file.

// Copyright (C) 2014-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef OPTIONAL_H
#define OPTIONAL_H
 
#include <exceptions/exceptions.h>
#include <ostream>
#include <string>
#include <type_traits>
 
namespace isc {
namespace util {

template<typename T>
class Optional {
public:

    typedef T ValueType;

    template<typename A>
    Optional<T>& operator=(A other) {
        default_ = other;
        unspecified_ = false;
        return (*this);
    }

    operator T() const {
        return (default_);
    }

    bool operator==(const T& other) const {
        return (default_ == other);
    }

    bool operator!=(const T& other) const {
        return (default_ != other);
    }

    // cppcheck-suppress nullPointer
    Optional()
        : default_(T(0)), unspecified_(true) {
    }

    template<typename A>
    Optional(A value, const bool unspecified = false)
        : default_(value), unspecified_(unspecified) {
    }

    // cppcheck-suppress returnByReference
    T get() const {
        return (default_);
    }

    T valueOr(T const& or_value) const {
        if (unspecified_) {
            return or_value;
        }
        return default_;
    }

    void unspecified(bool unspecified) {
        unspecified_ = unspecified;
    }

    bool unspecified() const {
        return (unspecified_);
    }

    bool empty() const {
        isc_throw(isc::InvalidOperation, "call to empty() not supported");
    }
 
protected:
    T default_;         
    bool unspecified_;  
 
private:
    // Refuse instantiation by a reference type.
    static_assert(!std::is_reference<T>::value, "!std::is_reference<T>::value");
};

template<>
inline Optional<std::string>::Optional()
    : default_(), unspecified_(true) {
}

template<>
inline bool Optional<std::string>::empty() const {
    return (default_.empty());
}

template<typename T>
std::ostream&
operator<<(std::ostream& os, const Optional<T>& optional_value) {
    os << optional_value.get();
    return (os);
}
 
 
} // end of namespace isc::util
} // end of namespace isc
 
#endif // OPTIONAL_VALUE_H