---

more/io/lock_file.h

Go to the documentation of this file.

//  Copyright (C) 2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file 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.
//
//  This file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: lock_file.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_IO_LOCK_FILE_H
#define MORE_IO_LOCK_FILE_H

#include <more/gen/utility.h>


namespace more {
namespace io {

  enum access_t
  {
      access_none = 0,
      access_x = 1,
      access_w = 2,
      access_wx = 3,
      access_r = 4,
      access_rx = 5,
      access_rw = 6,
      access_rwx = 7
  };
  inline access_t operator~(access_t acc) { return access_t(~int(acc)); }
  inline access_t operator&(access_t x, access_t y)
  {
      return access_t(int(x) & int(y));
  }
  inline access_t operator|(access_t x, access_t y)
  {
      return access_t(int(x) | int(y));
  }
  inline access_t& operator&=(access_t& x, access_t y) { return x = x & y; }
  inline access_t& operator|=(access_t& x, access_t y) { return x = x | y; }

  extern struct infinite_tag {} const infinite;

  /** A handle to a lock file.  Read-only locks are not NFS safe
   ** (TODO).  A workaround is to use \c access_rw also when only read
   ** access is needed. */
  struct lock_file : gen::noncopyable
  {
      /** Construct an undefined lock file handle. */
      lock_file()
          : m_access(access_none) {}

      /** Construct a handle for a named lock file, but do not create
       ** the file yet. */
      explicit lock_file(std::string path)
          : m_path(path),
            m_access(access_none) {}

//       /** Partially copy \a lf.  The path and access are copied, but
//        ** not the lock status.
//        ** \post <tt>this.have_lock() == false</tt>  */
//       lock_file(lock_file const& lf)
//        : m_path(lf.m_path),
//          m_access(access_none) {}

      /** Calls unlock(). */
      ~lock_file() { release(); }

      /** Set or change the file name of the lock.  This causes an
       ** unlock. */
      void set_file_name(std::string);

      /** Return the current access of the lock. */
      access_t access() const { return m_access; }

      /** Try to obtain the lock without blocking, and return true if
       ** successful.  The valid arguments for \a access are \c
       ** access_none, which causes an unlock, \c access_r which gives
       ** read access, and \c access_rw which gives read write access.
       ** In addition \c access_w will be changed to \c access_rw. */
      bool adjust(access_t access);

      /** Return \c adjust(acc | access()). */
      bool aquire(access_t acc) { return adjust(acc | access()); }

      /** Attempt every \a dt seconds for \a t seconds to \c
       ** aquire(access).  Return true if the lock was obtained.  See
       ** <tt>adjust(access_t)</tt> for constraint on \a access. */
      bool aquire(access_t access, double t, double dt = 1.0);

      /** Attempt every \a dt seconds indefinitely to \c
       ** aquire(access).  See <tt>adjust(access_t)</tt> for
       ** constraint on \a access. */
      bool aquire(access_t access, infinite_tag, double dt = 1.0);

      /** Release all access.  This function should ideally neither
       ** hang nor fail.  In the case of read-only locks, however, it
       ** may in exceptional cases hang for a few seconds, and
       ** possibly fail.  This may be the case if another program was
       ** interrupted at the critical stage while adjusting its own
       ** read-only lock, or if the lock files were tampered with. */
      void release(access_t access = access_rw);

      /** Swap two locks. */
      void swap(lock_file& lk)
      {
          std::swap(m_path, lk.m_path);
          std::swap(m_access, lk.m_access);
      }

      /** \depreciated Same ass release(). */
      void unlock() { release(); }

      /** \depreciated Use another constructor.
       ** Construct a handle and create the lock file with the given
       ** name if possible. If blocking=true it will hang until it
       ** manages to create the lock.  */
      lock_file(std::string path, bool blocking)
          : m_access(access_rw)
      {
          lock(path, blocking);
      }
      /** \depreciated Use \c access().
       ** Returns true after successful locking and before
       ** unlock(). */
      bool have_lock() const { return m_access == access_rw; }

      /** \depreciated
       ** Establish the lock with the given file name. */
      void lock(std::string path, bool blocking);

    private:
      std::string       m_path;
      access_t          m_access;
      int*              m_cnt;
  };

  struct lock_file_restorer
  {
      explicit lock_file_restorer(lock_file& lk)
          : m_lk(lk), m_acc(lk.access()) {}

      ~lock_file_restorer() { m_lk.adjust(m_acc); }

    private:
      lock_file& m_lk;
      access_t m_acc;
  };

}}

#endif

---