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

common.h

Go to the documentation of this file.

/*
 * Copyright © 2000, 2001 Sofus Mortensen
 *
 * 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_COMMON_H
#define COMET_COMMON_H

#include <comet/config.h>
#include <wtypes.h>

namespace comet {

        class uuid_t;
        template<typename Itf>class com_ptr;
        namespace impl {
                template<typename T> T* bad_alloc_check(T* x)
                {
                        if (!x) throw std::bad_alloc(); 
                        return x;
                }
        
                template<typename T> class auto_attach_t
                {
                public:
                        explicit auto_attach_t(const T& v) : val_(v) {}; 
                        const T& get() const { return val_; }
                private:
                        const T& val_;
                        auto_attach_t& operator=(const auto_attach_t&);
                };

                // Forward declare all these - only used if we actually WANT a
                // safearray.
                template<typename T> struct sa_traits;
                template<typename S,typename T> class sa_iterator;
                template<typename T> struct const_traits;
                template<typename T> struct nonconst_traits;

                enum sa_traits_check_type { stct_features_ok, stct_vt_ok, stct_iid_ok };
                enum sa_traits_extras_type { stet_null, stet_record, stet_iid };

                // Interface traits are needed by all interfaces so that we can create
                // safearrays of the types.
                template<typename INTERFACE, VARTYPE VT, long FEATURE_FLAG>
                struct interface_sa_traits
                {
                        enum { vt = VT };
                        enum { check_type = stct_iid_ok };
                        enum { extras_type = stet_iid };
                        
                        typedef INTERFACE* raw;
                        typedef com_ptr<INTERFACE>  value_type;
                        typedef com_ptr<INTERFACE> & reference;
                        typedef const com_ptr<INTERFACE> & const_reference;
                        
                        static reference create_reference(raw& x) { return *reinterpret_cast<com_ptr< INTERFACE>*>(&x); }
                        static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const com_ptr< INTERFACE >*>(&x); }
                        typedef nonconst_traits<com_ptr<INTERFACE> > nct;
                        typedef sa_iterator<com_ptr<INTERFACE>, nct > iterator;
                        typedef sa_iterator<com_ptr<INTERFACE>, const_traits<com_ptr<INTERFACE> > > const_iterator;

                        static bool are_features_ok(unsigned short f) { return (f & FEATURE_FLAG) != 0 && (f & FADF_HAVEIID) != 0; }
                        static const uuid_t& iid() { return uuidof<INTERFACE>(); }
                };

                template<typename T, VARTYPE VT> struct basic_sa_traits 
                {
                        enum { vt = VT };
                        enum { check_type = stct_vt_ok };
                        enum { extras_type = stet_null };
                        
                        typedef T raw;
                        typedef T value_type;
                        typedef T& reference;
                        typedef const T& const_reference;
                        
                        static reference create_reference(T& x) { return x; }
                        static const_reference create_const_reference(T& x) { return x; }
                        
                        typedef T* iterator;
                        typedef const T* const_iterator;

                        static bool are_features_ok(unsigned short) { return true; }
                };
        }
        

        template<typename T> impl::auto_attach_t<T> auto_attach(const T& t) { return impl::auto_attach_t<T>(t); }


//      template<typename T, typename U> inline T up_cast(const U& u, T* = 0) { return u; }


        inline VARIANT_BOOL bool_in(bool x) { return x ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; }

        class bool_out {
        public:
                operator VARIANT_BOOL*() { return &vb_; }
                bool_out(bool& b) : b_(b) {}
                ~bool_out() { b_ = vb_ ? true : false; } 
        private:
                bool_out &operator=( const bool_out &);
                VARIANT_BOOL vb_;
                bool& b_;
        };

        namespace impl {
                class bool_adapter_t {
                public:
                        bool_adapter_t(VARIANT_BOOL* p) : pb_(p) { b_ = *pb_ ? true : false; }
                        ~bool_adapter_t() { *pb_ = b_ ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE; }

                        bool& ref() { return b_; }
                private:
                        bool_adapter_t(const bool_adapter_t&);
                        bool_adapter_t& operator=(const bool_adapter_t&);

                        VARIANT_BOOL* pb_;
                        bool b_;
                };
        }

        class bool_inout {
        public:
                operator VARIANT_BOOL*() { return &vb_; }
                bool_inout(bool& b) : b_(b), vb_(b ? COMET_VARIANT_TRUE : COMET_VARIANT_FALSE) {}
                ~bool_inout() { b_ = vb_ ? true : false; } 
        private:
                bool_inout &operator=(const bool_inout &);
                VARIANT_BOOL vb_;
                bool& b_;
        };

        class variant_bool_t
        {
                VARIANT_BOOL vb_;
        public:

                variant_bool_t(): vb_(COMET_VARIANT_FALSE) {}
                variant_bool_t(const impl::auto_attach_t<VARIANT_BOOL> &b) : vb_(b.get()) {}
                variant_bool_t(bool b) : vb_(b?COMET_VARIANT_TRUE:COMET_VARIANT_FALSE) {}


                variant_bool_t &operator=( bool b) { vb_ = b?COMET_VARIANT_TRUE:COMET_VARIANT_FALSE;  return *this;}
                variant_bool_t &operator=( const impl::auto_attach_t<VARIANT_BOOL> &b) { vb_ = b.get(); return *this; }


                operator bool() const{ return vb_!= COMET_VARIANT_FALSE; }
                bool operator !() const { return vb_== COMET_VARIANT_FALSE; }
                bool operator==( variant_bool_t vb) const { return vb.vb_ == vb_; }
                bool operator!=( variant_bool_t vb) const { return vb.vb_ != vb_; }


                variant_bool_t operator~() const { variant_bool_t temp(*this); temp.vb_ = (VARIANT_BOOL)~(temp.vb_); return temp; }
                variant_bool_t &operator&=( const variant_bool_t &b) { vb_ &= b.vb_; return *this; }
                variant_bool_t &operator|=( const variant_bool_t &b) { vb_ |= b.vb_; return *this; }
                variant_bool_t &operator^=( const variant_bool_t &b) { vb_ ^= b.vb_; return *this; }
                variant_bool_t operator&( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ &= b.vb_; return temp; }
                variant_bool_t operator|( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ |= b.vb_; return temp; }
                variant_bool_t operator^( const variant_bool_t &b)const { variant_bool_t temp(*this); temp.vb_ ^= b.vb_; return temp; }


                bool operator&( bool b)const { return b & operator bool(); }
                bool operator|( bool b)const { return b | operator bool(); }
                bool operator^( bool b)const { return b ^ operator bool(); }

                static const variant_bool_t &create_const_reference(const VARIANT_BOOL &vb) { return reinterpret_cast<const variant_bool_t &>(vb); }
                static variant_bool_t &create_reference(VARIANT_BOOL &vb) { return reinterpret_cast<variant_bool_t &>(vb); }


                VARIANT_BOOL in() { return vb_; }
                VARIANT_BOOL *out() { return &vb_; }
                VARIANT_BOOL *inout() { return &vb_; }


                class bool_pointer_t
                {
                        friend class variant_bool_t;
                        protected:
                                bool_pointer_t( VARIANT_BOOL &vb) :  vb_(vb), b_( vb != COMET_VARIANT_FALSE) {}
                        public:
                                ~bool_pointer_t() { vb_ = b_ ? COMET_VARIANT_TRUE: COMET_VARIANT_FALSE; }
                                operator bool*(){ return &b_; }
                                operator const bool*()const{ return &b_; }
                        private:
                                bool_pointer_t &operator=(const bool_pointer_t &);
                                bool b_;
                                VARIANT_BOOL &vb_;
                };
                bool_pointer_t bool_ptr()
                {
                        return bool_pointer_t(vb_);
                }
                const bool_pointer_t bool_ptr() const
                {
                        return bool_pointer_t(const_cast<VARIANT_BOOL &>(vb_));
                }

                friend class bool_reference_t;
                class bool_reference_chooser_t
                {
                        friend class variant_bool_t;
                        variant_bool_t &vbt_;
                protected:
                        bool_reference_chooser_t(variant_bool_t &vbt):vbt_(vbt) {}
                private:
                        bool_reference_chooser_t &operator=(const bool_reference_chooser_t &);
                public:
                        inline operator variant_bool_t&() { return vbt_;}
                        inline operator const variant_bool_t&()const { return vbt_;}
                };
                class bool_reference_t : protected bool_pointer_t
                {
                        public:
                                bool_reference_t( bool_reference_chooser_t &brc )
                                        : bool_pointer_t(*static_cast<variant_bool_t&>(brc).inout())
                                        {}
                                operator bool &(){ return tmp; /*return * (bool_pointer_t::operator bool*());*/ }
                                operator const bool &()const { return *(bool_pointer_t::operator const bool*()); }
                                bool tmp;
                };

                bool_reference_chooser_t bool_ref()
                {
                        return bool_reference_chooser_t(*this);
                }
                const bool_reference_chooser_t bool_ref() const
                {
                        return bool_reference_chooser_t(const_cast<variant_bool_t &>(*this));
                }
        };

} // namespace

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.