RulbusDeviceProxy.h

/*
 * RulbusDeviceProxy.h - class RulbusDeviceProxy.
 *
 * This file is part of the Rulbus Device Class Library (RDCL).
 *
 * Copyright (C) 2003-2004, Leiden University.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mngdriver; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: RulbusDeviceProxy.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __RULBUSDEVICEPROXY_H
#define __RULBUSDEVICEPROXY_H

#ifndef __COMMON_H
   #include "Common.h"
#endif

#include "winutils/semaphore.h" // for WindowsUtils::Semaphore
#include <windows.h>            // for InterlockedIncrement()

namespace WindowsUtils
{
   DECLARE_CLASS( Semaphore );
}

namespace Rulbus
{
   DECLARE_CLASS( RulbusDevice      );
   DECLARE_CLASS( RulbusDeviceProxy );

   class RulbusDeviceProxy
   {
   public:
      RulbusDeviceProxy  ( RulbusDevicePtr aPtr     );
      RulbusDeviceProxy  ( RulbusDeviceProxyRef rhs );
      ~RulbusDeviceProxy ( );

      RulbusDeviceProxyRef operator= ( RulbusDeviceProxyRef rhs );

                           operator RulbusDevicePtr ( );
                           operator RulbusDeviceRef ( );

      RulbusDevicePtr      operator->( );
      RulbusDeviceRef      operator* ( );

      RulbusDeviceRef      get( );

   protected:
      RulbusDevicePtr      transfer();

   protected:
      RulbusDevicePtr      thePtr;              
      static WindowsUtils::Semaphore s;         
   };

   inline RulbusDeviceProxy::RulbusDeviceProxy( RulbusDevicePtr aPtr ) :
      thePtr( aPtr )
   {
      s.wait();
   }

   inline RulbusDeviceProxy::RulbusDeviceProxy( RulbusDeviceProxyRef rhs ) :
      thePtr( rhs.transfer() )
   {
      ; // do nothing
   }

   inline RulbusDeviceProxy::~RulbusDeviceProxy( )
   {
      if ( thePtr )
      {
         s.post();                              // critical section end
         thePtr = 0;
      }
      else
      {
         ; // do nothing
      }
   }

   RulbusDeviceProxyRef RulbusDeviceProxy::operator=( RulbusDeviceProxyRef rhs )
   {
      thePtr = rhs.transfer();

      return *this;
   }

   inline RulbusDeviceProxy::operator RulbusDevicePtr( )
   {
      return &get();
   }

   inline RulbusDeviceProxy::operator RulbusDeviceRef( )
   {
      return get();
   }

   inline RulbusDevicePtr RulbusDeviceProxy::operator->( )
   {
      return &get();
   }

   inline RulbusDeviceRef RulbusDeviceProxy::operator*( )
   {
      return get();
   }

   RulbusDeviceRef RulbusDeviceProxy::get()
   {
      return *thePtr;
   }

   RulbusDevicePtr RulbusDeviceProxy::transfer()
   {
      RulbusDevicePtr tmpPtr = thePtr;
      thePtr                 = 0;

      return tmpPtr;
   }

   template <typename T>
   inline T to( RulbusDeviceProxyRef proxy )
   {
      return PROXY_CAST( T, static_cast<RulbusDevicePtr>( proxy ) );
   }

}       // namespace Rulbus

#endif  // __RULBUSDEVICEPROXY_H

/*
 * end of file
 */

---