# sol2 3.5.0 documentation

## unique_usertype_traits<T>

### Search the Documentation

# unique_usertype_traits<T>

trait for hooking special handles / pointers

unique_usertype

    template <typename T>
    struct unique_usertype_traits {
            typedef T type;
            typedef T actual_type;
            static const bool value = false;

            static bool is_null(const actual_type&) {...}

            static type* get (const actual_type&) {...}
    };

This is a customization point for users who need to work with special kinds of pointers/handles. The traits type alerts the library that a certain type is to be pushed as a special userdata with special deletion / destruction semantics, like many smart pointers / custom smart pointers / handles. It is already defined for `std::unique_ptr<T, D>` and `std::shared_ptr<T>` and works properly with those types (see shared_ptr here and unique_ptr here for examples). You can specialize this to get `unique_usertype_traits` semantics with your code. For example, here is how `boost::shared_ptr<T>` would look:

    namespace sol {
            template <typename T>
            struct unique_usertype_traits<boost::shared_ptr<T>> {
                    typedef T type;
                    typedef boost::shared_ptr<T> actual_type;
                    static const bool value = true;

                    static bool is_null(const actual_type& ptr) {
                            return ptr == nullptr;
                    }

                    static type* get (const actual_type& ptr) {
                            return ptr.get();
                    }
            };
    }

This will allow the library to properly handle `boost::shared_ptr<T>`, with ref-counting and all. The `type` is the type that lua and sol will interact with, and will allow you to pull out a non-owning reference / pointer to the data when you just ask for a plain `T*` or `T&` or `T` using the getter functions and properties of sol. The `actual_type` is just the “real type” that controls the semantics (shared, unique, `CComPtr`, `ComPtr`, OpenGL handles, DirectX objects, the list goes on).

Note

If `is_null` triggers (returns `true`), a `nil` value will be pushed into Lua rather than an empty structure.