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

module.h

Go to the documentation of this file.

/*
 * Copyright © 2000-2002 Sofus Mortensen, Paul Hollingsworth, Michael Geddes, Mikael Lindgren
 *
 * 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_MODULE_H
#define COMET_MODULE_H

#include <vector>
#include <comet/config.h>
#include <comet/tstring.h>
#include <comet/threading.h>

namespace comet {

        namespace impl {
                struct cmd_t
                {
                        virtual void cmd() = 0;
                        cmd_t() {}
                private:
                        cmd_t(const cmd_t&);
                        cmd_t& operator=(const cmd_t&);
                };

                template<typename T>
                struct itf_releaser_t : public cmd_t
                {
                        void cmd() { IUnknown *p = p_; p_=NULL; p->Release(); }
                        itf_releaser_t(T *&p) :p_(p) { }
                private:
                        T *&p_;
                        itf_releaser_t(const itf_releaser_t&);
                        itf_releaser_t& operator=(const itf_releaser_t&);
                };

                template<typename T>
                cmd_t *create_itf_releaser( T *&p)
                {
                        return new itf_releaser_t<T>(p);
                }

                template<typename T>
                struct pointer_deleter_t : public cmd_t
                {
                        void cmd() { T *p = p_; p_=NULL; delete p;}
                        pointer_deleter_t(T *&p) :p_(p) { }
                private:
                        T *&p_;
                        pointer_deleter_t(const pointer_deleter_t&);
                        pointer_deleter_t& operator=(const pointer_deleter_t&);
                };

                template<typename T>
                struct object_disposer_t : public cmd_t
                {
                        void cmd() { p_->object_dispose(); }
                        object_disposer_t( T*p) : p_(p) {}
                private:
                        T *p_;
                        object_disposer_t(const object_disposer_t &);
                        object_disposer_t &operator=(const object_disposer_t &);
                };
        }

        template<typename T>
        impl::cmd_t *create_pointer_deleter( T *&p)
        {
                return new impl::pointer_deleter_t<T>(p);
        }

        template<typename T>
        impl::cmd_t *create_interface_releaser( T *&p)
        {
                return new impl::itf_releaser_t<T>(p);
        }


        template<typename T>
        impl::cmd_t *create_object_disposer( T *p )
        {
                return new impl::object_disposer_t<T>(p);
        }

        struct module_t
        {


                long rc()
                {
                        return rc_;
                }
                HINSTANCE instance() const
                {
                        return instance_;
                }

                void instance(HINSTANCE h)
                {
                        instance_ = h;
                }


                const critical_section& cs() const
                {
                        return cs_;
                }




                void lock()
                {
                        if (InterlockedIncrement(&rc_) == 1 && shutdown_event_ != 0)
                        {
                                auto_cs lock(cs_);
                                if ( shutdown_event_->is_set())
                                        shutdown_event_->reset();
                        }
                }

                void unlock()
                {
                        if(InterlockedDecrement(&rc_)==0)
                        {
                                activity_ = true;
                                if (shutdown_event_ != 0)
                                {
                                        auto_cs lock(cs_);
                                        shutdown_event_->set();
                                }
                        }
                }

                void shutdown()
                {
                        for (std::vector<impl::cmd_t*>::iterator it = objects_to_dispose_.begin(); it != objects_to_dispose_.end(); ++it)
                        {
                                (*it)->cmd();
                                delete *it;
                        }
                        objects_to_dispose_.clear();
                }

                void set_shutdown_event(event& shutdown_event)
                {
                        shutdown_event_ = &shutdown_event;
                }

                void clear_shutdown_event()
                {
                        shutdown_event_ = 0;
                }

                bool has_activity() const
                {
                        return rc_ != 0 || activity_;
                }

                void reset_activity_flag()
                {
                        activity_ = false;
                }

                void add_object_to_dispose(impl::cmd_t* p)
                {
                        auto_cs lock(cs_);
                        objects_to_dispose_.push_back(p);
                }

        private:
                long rc_;
                bool activity_;
                event* shutdown_event_;
                HINSTANCE instance_;
                critical_section cs_;

                module_t() : rc_(0), activity_(false),
                                         shutdown_event_(0), instance_(0)
                {}

                std::vector<impl::cmd_t*> objects_to_dispose_;

                friend module_t& module();

                // declare non-copyable
                module_t(const module_t&);
                module_t& operator=(const module_t&);
        };

        inline module_t& module()
        {
                static module_t m;
                return m;
        }
}

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.