home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

handle.h

Go to the documentation of this file.

/*
* Copyright © 2001,2004 Sofus Mortensen, Michael Geddes
*
* This material is provided "as is", with absolutely no warranty
* expressed or implied. Any use is at your own risk. Permission to
* use or copy this software for any purpose is hereby granted without
* fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is
* granted, provided the above notices are retained, and a notice that
* the code was modified is included with the above copyright notice.
*
* This header is part of comet.
* http://www.lambdasoft.dk/comet
*/

#ifndef COMET_HANDLE_H
#define COMET_HANDLE_H

#include <comet/config.h>
#include <comet/static_assert.h>
#include <comet/error_fwd.h>
#include <comet/common.h>
#include <comet/assert.h>

#include <algorithm>

namespace comet {


        template< typename H, long INVALID_HANDLE_ >
        class handle_policy_base_t
        {
                public:
                        handle_policy_base_t() : handle_(reinterpret_cast<H>(INVALID_HANDLE_)) {}

                        explicit handle_policy_base_t( H handle) : handle_(handle) {}

                        typedef H value_type;

                        operator H() const throw()
                        {
                                // This function seemed not to work with returning a namespaced
                                // type.
                                return handle_;
                        }
                        static inline H invalid_handle() { return reinterpret_cast<H>(INVALID_HANDLE_) ;}

                        bool valid() const
                        {
                                return handle_ != invalid_handle();
                        }

                        H detach_handle()
                        {
                                return swap_handle(invalid_handle());
                        }

                        static inline value_type detach( handle_policy_base_t &handle )throw()
                        {
                                return handle.detach_handle();
                        }

                protected:
                        ~handle_policy_base_t()
                        { }

                        void detach_to(handle_policy_base_t &rhs) throw()
                        {
                                value_type handle(handle_);
                                handle_= invalid_handle();
                                rhs.handle_ = handle;
                        }

                        H get_handle() const { return handle_; }
                        H *get_handle_ptr() { return &handle_;}

                        H swap_handle(H new_handle)
                        {
                                H old = handle_;
                                handle_ = new_handle;
                                return old;
                        }

                private:
                        H handle_;
        };

        struct handle_nothrow_error_policy_t
        {
                static void on_error()
                { }
        };

        struct handle_throw_error_policy_t
        {
                static void on_error()
                {
                        DWORD err = GetLastError();
                        raise_exception(HRESULT_FROM_WIN32(err));
                }
        };

        template<typename C_, typename H, long INVALID_HANDLE_, typename ERROR_POLICY>
        class auto_handle_wrap_t : public handle_policy_base_t<H, INVALID_HANDLE_>
        {
                protected:
                        static inline bool destroy_( value_type h)
                        {
                                return C_::destroy_handle(h);
                        }


                        static bool destroy_handle(value_type h);

                        typedef handle_policy_base_t<H, INVALID_HANDLE_> policy_base ;

                        void set_handle( value_type h ) throw()
                        {
                                destroy_(swap_handle( h));
                        }

                        static bool expect_nonzero( BOOL value)
                        {
                                bool is_ok = (value != FALSE);
                                if (!is_ok)
                                        ERROR_POLICY::on_error();
                                return is_ok;
                        }
                public:

                        auto_handle_wrap_t() throw()
                        {}

                        typedef const C_ &ref;

                        auto_handle_wrap_t( const impl::auto_attach_t<typename policy_base::value_type> &handle ) throw()
                                : policy_base(handle.get())
                                {}

                        auto_handle_wrap_t( auto_handle_wrap_t &rhs) throw()
                        {
                                rhs.detach_to(*this);
                        }

                        auto_handle_wrap_t( policy_base &rhs) throw()
                        {
                                rhs.detach_to(*this);
                        }

                        ~auto_handle_wrap_t() throw()
                        {
                                destroy_(get());
                        }



                        template<typename EP>
                                auto_handle_wrap_t<C_, H, INVALID_HANDLE_, EP> & operator=(auto_handle_wrap_t<C_, H, INVALID_HANDLE_, EP>& rhs) throw()
                                {
                                        close_handle();
                                        rhs.detach_to(*this);
                                        return *this;
                                }

                        C_ &operator=(const impl::auto_attach_t<value_type> &handle )
                        {
                                close_handle();
                                set_handle(handle.get());
                                return *static_cast<C_ *>(this);
                        }

                        bool close() throw()
                        {
                                return destroy_(policy_base::detach(*this));
                        }




                        typename policy_base::value_type* out() throw()
                        {
                                close_handle();
                                return get_handle_ptr();
                        }

                        typename policy_base::value_type get() const throw()
                        { return get_handle(); }
                        typename policy_base::value_type in() const throw()
                        { return get_handle(); }
                        typename policy_base::value_type *inout() throw()
                        { return get_handle_ptr(); }

                        static inline const C_ &create_const_reference(const value_type &val)
                        { return *reinterpret_cast<const C_ *>(&val); }

                        static inline C_ &create_reference(value_type &val)
                        { return *reinterpret_cast<C_ *>(&val); }

                        static bool destroy_reference(value_type H) 
                        {
                                return true;
                        }

                private:

                        inline void close_handle()
                        {
                                if (!close())
                                        ERROR_POLICY::on_error();
                        }
        };

        namespace impl
        {
                class THIS_IS_NOT_ALLOWED
                {
                        ~THIS_IS_NOT_ALLOWED() {}
                };
        }

        template< typename H, long INVALID_HANDLE_ >
        inline impl::THIS_IS_NOT_ALLOWED CloseHandle(const handle_policy_base_t<H,INVALID_HANDLE_>&);


        template< typename H, long INVALID_HANDLE_ >
        bool CloseHandle(handle_policy_base_t<H,INVALID_HANDLE_> &rhs)
        {
                return rhs.close();
        }

        template< typename ERROR_POLICY = handle_nothrow_error_policy_t >
        struct auto_handle_t : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY >
        {
                typedef auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY > handle_base;

                auto_handle_t() {}
                auto_handle_t( auto_handle_t &rhs)
                        : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY >(rhs)
                {}

                auto_handle_t( const impl::auto_attach_t< HANDLE > &rhs )
                        : auto_handle_wrap_t< auto_handle_t, HANDLE, 0, ERROR_POLICY >(rhs)
                { }
                auto_handle_t &operator=(auto_handle_t &rhs)
                {
                        handle_base::operator=(rhs);
                        return *this;
                }
                auto_handle_t  &operator=( const impl::auto_attach_t<HANDLE> &rhs)
                {
                        handle_base::operator=(rhs);
                        return *this;
                }

                static bool destroy_handle( HANDLE h)
                {
                        return ::CloseHandle(h) != FALSE;
                }

        };

        typedef auto_handle_t<> auto_handle;
        typedef auto_handle_t< handle_throw_error_policy_t > auto_handle_throw;

        template <typename T>
        struct auto_reference_t : T
        {
                auto_reference_t( const comet::impl::auto_attach_t<typename T::value_type> &rhs ) : T(rhs)
                {}
                ~auto_reference_t()
                {
                        destroy_reference(detach_handle());
                }
        };
}

using comet::CloseHandle;

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.