some.h

Go to the documentation of this file.

#ifndef __SG_SOME_H__
#define __SG_SOME_H__

#include <shogun/lib/config.h>

#ifdef HAVE_CXX11
#include <memory>

#include <shogun/base/SGObject.h>

namespace shogun
{

    template <typename T>
        class Some
        {
            public:
                Some(const Some<T>& other);
                explicit Some(T* other);
                Some& operator=(T* other);
                ~Some();

                static Some<T> from_raw(T* raw);

                operator T*();
                T* operator->();
            private:
                Some();
                void unref();
                void ref();
            private:
                T* raw;
        };

    template <typename T>
    Some<T>::Some()
    : raw(nullptr)
    {
    }
    template <typename T>
    Some<T>::Some(const Some<T>& other)
    : raw(other.raw)
    {
        ref();
    }
    template <typename T>
    Some<T>::Some(T* other)
    : raw(other)
    {
        ref();
    }
    template <typename T>
    Some<T>& Some<T>::operator=(T* other)
    {
        if (raw != other) {
            unref();
            raw = other;
            ref();
        }
        return *this;
    }
    template <typename T>
    Some<T>::~Some()
    {
        unref();
    }
    template <typename T>
    Some<T>::operator T*()
    {
        return raw;
    }
    template <typename T>
    T* Some<T>::operator->()
    {
        return raw;
    }
    template <typename T>
    void Some<T>::ref()
    {
        SG_REF(raw);
    }
    template <typename T>
    void Some<T>::unref()
    {
        SG_UNREF(raw);
    }
    template <typename T>
    Some<T> Some<T>::from_raw(T* raw)
    {
        Some<T> result(raw);
        return result;
    }

    template <typename T, class... Args>
    Some<T> some(Args&&... args)
    {
        T* ptr = new T(args...);
        return Some<T>::from_raw(ptr);
    }

    template <class T>
    inline T wrap(const T& value)
    {
        return value;
    }

    template <class T>
    inline Some<T> wrap(T* ptr)
    {
        return Some<T>::from_raw(ptr);
    }

    template <class T>
    inline Some<T> wrap(const Some<T>& other)
    {
        return other;
    }

};

#endif /* HAVE_CXX11 */
#endif /* __SG_SOME_H__ */