guarded.hpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

////////////////////////////////////////////////////////////////////////////////

#ifndef MORE_UTIL_GUARDED_HPP
#define MORE_UTIL_GUARDED_HPP

////////////////////////////////////////////////////////////////////////////////

#include <cstddef>
#include <more/compiler.hpp>
#include <more/exception.hpp>

////////////////////////////////////////////////////////////////////////////////

namespace more
{
  namespace util
  {
    class Guarded
    {
      public:
        virtual void acquire( ) = 0;
        virtual void release( ) = 0;

      protected:
        virtual ~Guarded( );
    };

    class TimelyGuarded: public Guarded
    {
      public:
        class TimeOut: public more::Exception
        {
          public:
            virtual operator const char* ( ) const = 0;
        };

        virtual void acquire( size_t nMillisecondsToWait ) throw( TimeOut ) = 0;

      protected:
        virtual ~TimelyGuarded( );
    };

    class Guard
    {
      public:
        Guard( TimelyGuarded*, size_t nMillisecondsToWait ) throw( TimelyGuarded::TimeOut );
        Guard( Guarded* );
       ~Guard( );

      private:
        Guarded* m_pGuarded;
    };

    class ReverseGuard
    {
      public:
        ReverseGuard( Guarded* );
       ~ReverseGuard( );

      private:
        Guarded* m_pGuarded;
    };
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::Guard::Guard
(
  more::util::TimelyGuarded*  pTimelyGuarded,
  size_t                      nMillisecondsToWait

) throw( TimelyGuarded::TimeOut )

: m_pGuarded( 0 )
{
  if( pTimelyGuarded != 0 )
  {
    pTimelyGuarded -> acquire( nMillisecondsToWait );
    m_pGuarded = pTimelyGuarded;
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::Guard::Guard
(
  more::util::Guarded* pGuarded
)
: m_pGuarded( pGuarded )
{
  if( m_pGuarded != 0 )
  {
    m_pGuarded -> acquire( );
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::Guard::~Guard( )
{
  if( m_pGuarded != 0 )
  {
    m_pGuarded -> release( );
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::ReverseGuard::ReverseGuard
(
  more::util::Guarded* pGuarded
)
: m_pGuarded( pGuarded )
{
  if( m_pGuarded != 0 )
  {
    m_pGuarded -> release( );
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::ReverseGuard::~ReverseGuard( )
{
  if( m_pGuarded != 0 )
  {
    m_pGuarded -> acquire( );
  }
}

////////////////////////////////////////////////////////////////////////////////

#endif