blocxx

SharedLibraryReference.hpp

Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2005, Vintela, Inc. All rights reserved.
00003 * Copyright (C) 2006, Novell, Inc. All rights reserved.
00004 * 
00005 * Redistribution and use in source and binary forms, with or without
00006 * modification, are permitted provided that the following conditions are met:
00007 * 
00008 *     * Redistributions of source code must retain the above copyright notice,
00009 *       this list of conditions and the following disclaimer.
00010 *     * Redistributions in binary form must reproduce the above copyright
00011 *       notice, this list of conditions and the following disclaimer in the
00012 *       documentation and/or other materials provided with the distribution.
00013 *     * Neither the name of 
00014 *       Vintela, Inc., 
00015 *       nor Novell, Inc., 
00016 *       nor the names of its contributors or employees may be used to 
00017 *       endorse or promote products derived from this software without 
00018 *       specific prior written permission.
00019 * 
00020 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00021 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00022 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00023 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00024 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00025 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00026 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00027 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00028 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00029 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00030 * POSSIBILITY OF SUCH DAMAGE.
00031 *******************************************************************************/
00032 
00033 
00038 #ifndef BLOCXX_SHARED_LIBRARY_REFERENCE_HPP_
00039 #define BLOCXX_SHARED_LIBRARY_REFERENCE_HPP_
00040 #include "blocxx/BLOCXX_config.h"
00041 #include "blocxx/SharedLibrary.hpp"
00042 
00043 namespace BLOCXX_NAMESPACE
00044 {
00045 
00046 template <class T>
00047 class SharedLibraryReference
00048 {
00049 public:
00050    typedef T element_type;
00051 
00052    SharedLibraryReference(const SharedLibraryRef& lib, const T& obj)
00053    : m_sharedLib(lib), m_obj(obj)
00054    {}
00055    SharedLibraryReference(const SharedLibraryRef& lib, typename T::element_type* obj)
00056    : m_sharedLib(lib), m_obj(T(obj))
00057    {}
00058    SharedLibraryReference(const SharedLibraryReference<T>& arg)
00059    : m_sharedLib(arg.m_sharedLib), m_obj(arg.m_obj)
00060    {
00061    }
00062    /* construct out of a reference to a derived type.  U should be
00063    derived from T */
00064    template <class U>
00065    SharedLibraryReference(const SharedLibraryReference<U>& arg)
00066    : m_sharedLib(arg.m_sharedLib), m_obj(arg.m_obj)
00067    {
00068    }
00069    SharedLibraryReference()
00070    : m_sharedLib(), m_obj()
00071    {}
00072    SharedLibraryReference<T>& operator=(const SharedLibraryReference<T>& arg)
00073    {
00074       m_obj = arg.m_obj;
00075       m_sharedLib = arg.m_sharedLib;
00076       return *this;
00077    }
00078    ~SharedLibraryReference()
00079    {
00080       try
00081       {
00082          m_obj = 0;
00083          m_sharedLib = 0;
00084       }
00085       catch (...)
00086       {
00087          // don't let exceptions escape
00088       }
00089    }
00090    SharedLibraryRef getLibRef() const
00091    {
00092       return m_sharedLib;
00093    }
00094    typename T::element_type* operator->() const
00095    {
00096       return &*m_obj;
00097    }
00098    T get() const
00099    {
00100       return m_obj;
00101    }
00102    
00103    typedef T SharedLibraryReference::*safe_bool;
00104    operator safe_bool () const
00105       {  return (m_obj) ? &SharedLibraryReference::m_obj : 0; }
00106    bool operator!() const
00107       {  return !m_obj; }
00108    void setNull()
00109    {
00110       m_obj = 0;
00111       m_sharedLib = 0;
00112    }
00113    
00114    template <class U>
00115    SharedLibraryReference<U> cast_to() const
00116    {
00117       SharedLibraryReference<U> rval;
00118       rval.m_sharedLib = m_sharedLib;
00119       rval.m_obj = m_obj.cast_to<U>();
00120       return rval;
00121    }
00122 
00123    BLOCXX_DEPRECATED bool isNull() const // in 3.1.0
00124    {
00125       return !m_obj;
00126    }
00127 
00128 #if !defined(__GNUC__) || __GNUC__ > 2 // causes gcc 2.95 to ICE
00129    /* This is so cast_to will work */
00130    template <class U> friend class SharedLibraryReference;
00131 
00132 private:
00133 #endif
00134 
00135    SharedLibraryRef m_sharedLib;
00136    T m_obj;
00137 };
00138 
00139 } // end namespace BLOCXX_NAMESPACE
00140 
00141 #endif