vrpn_ConnectionPtr.h

浏览该文件的文档.

 
//          Copyright Iowa State University 2011.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef INCLUDED_vrpn_ConnectionPtr_h_GUID_52044DCC_1409_4F8B_FC18_0F80285ABDBE
#define INCLUDED_vrpn_ConnectionPtr_h_GUID_52044DCC_1409_4F8B_FC18_0F80285ABDBE
 
// Internal Includes
// - none
 
// Library/third-party includes
#include <vrpn_Connection.h>
#include <vrpn_MainloopObject.h>
 
// Standard includes
// - none
 
class vrpn_ConnectionPtr {
public:
 explicit vrpn_ConnectionPtr(vrpn_Connection* c = NULL)
        : _p(c)
    {
 if (_p) {
            _p->addReference();
        }
    }
 
 vrpn_ConnectionPtr(vrpn_ConnectionPtr const& other)
        : _p(other._p)
    {
 if (_p) {
            _p->addReference();
        }
    }
 
 vrpn_ConnectionPtr& operator=(vrpn_ConnectionPtr const& other)
    {
 if (this == &other || _p == other._p) {
 return *this;
        }
 
 reset();
 if (other._p) {
            _p = other._p;
            _p->addReference();
        }
 return *this;
    }
 
 vrpn_ConnectionPtr& operator=(vrpn_Connection* other)
    {
 if (_p == other) {
 return *this;
        }
 
 reset();
 if (other) {
            _p = other;
            _p->addReference();
        }
 return *this;
    }
 
 ~vrpn_ConnectionPtr() { reset(); }
 
 void reset()
    {
 if (_p) {
            _p->removeReference();
        }
        _p = NULL;
    }
 
 vrpn_Connection* get() const { return _p; }
 
 vrpn_Connection& operator*() { return *_p; }
 
 vrpn_Connection const& operator*() const { return *_p; }
 
 vrpn_Connection* operator->() { return _p; }
 
 vrpn_Connection const* operator->() const { return _p; }
 
 bool operator!() const { return !_p; }
 
 typedef vrpn_Connection* vrpn_ConnectionPtr::*unspecified_bool_type;
 operator unspecified_bool_type() const
 {
 return (this->operator!()) ? &vrpn_ConnectionPtr::_p : NULL;
    }
 
 static vrpn_ConnectionPtr
    create_server_connection(int port = vrpn_DEFAULT_LISTEN_PORT_NO,
 const char* local_in_logfile_name = NULL,
 const char* local_out_logfile_name = NULL,
 const char* NIC_NAME = NULL)
    {
 return vrpn_ConnectionPtr(
            vrpn_create_server_connection(port, local_in_logfile_name,
                                          local_out_logfile_name, NIC_NAME),
 false);
    }
 
 static vrpn_ConnectionPtr
    create_server_connection(const char* cname,
 const char* local_in_logfile_name = NULL,
 const char* local_out_logfile_name = NULL)
    {
 return vrpn_ConnectionPtr(
            vrpn_create_server_connection(cname, local_in_logfile_name,
                                          local_out_logfile_name),
 false);
    }
 
private:
 vrpn_ConnectionPtr(vrpn_Connection* c, bool needsAddRef)
        : _p(c)
    {
 if (_p && needsAddRef) {
            _p->addReference();
        }
    }
 
 vrpn_Connection* _p;
 
 void this_type_does_not_support_comparisons() const {}
};
 
inline bool operator==(const vrpn_ConnectionPtr& lhs,
 const vrpn_ConnectionPtr& rhs)
{
 return lhs.get() == rhs.get();
}
 
inline bool operator!=(const vrpn_ConnectionPtr& lhs,
 const vrpn_ConnectionPtr& rhs)
{
 return lhs.get() != rhs.get();
}
 
#if 0
template <typename T>
bool operator!=(const T& lhs, const vrpn_ConnectionPtr& rhs) {
    rhs.this_type_does_not_support_comparisons();
 return false;
}
 
template <typename T>
bool operator==(const T& lhs, const vrpn_ConnectionPtr& rhs) {
    rhs.this_type_does_not_support_comparisons();
 return false;
}
 
template <typename T>
bool operator!=(const vrpn_ConnectionPtr& lhs, const T& rhs) {
    lhs.this_type_does_not_support_comparisons();
 return false;
}
 
template <typename T>
bool operator==(const vrpn_ConnectionPtr& lhs, const T& rhs) {
    lhs.this_type_does_not_support_comparisons();
 return false;
}
#endif
 
namespace detail {
 template <class T> class TypedMainloopObject;
 
 template <>
 class TypedMainloopObject<vrpn_ConnectionPtr> : public vrpn_MainloopObject {
 public:
 explicit TypedMainloopObject(vrpn_ConnectionPtr o)
            : _instance(o)
        {
 if (!o) {
 throw vrpn_MainloopObject::
                    CannotWrapNullPointerIntoMainloopObject();
            }
        }
 
 virtual bool broken() { return (!_instance->doing_okay()); }
 
 virtual void mainloop() { _instance->mainloop(); }
 
 protected:
 virtual void* _returnContained() const { return _instance.get(); }
 
 private:
 vrpn_ConnectionPtr _instance;
    };
} // end of namespace detail
 
#endif // INCLUDED_vrpn_ConnectionPtr_h_GUID_52044DCC_1409_4F8B_FC18_0F80285ABDBE