file_lock.hpp

//--------------------------------------------------------------------------------------------------
// Copyright (c) 2019 Marcus Geelnard
//
// This software is provided 'as-is', without any express or implied warranty. In no event will the
// authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose, including commercial
// applications, and to alter it and redistribute it freely, subject to the following restrictions:
//
//  1. The origin of this software must not be misrepresented; you must not claim that you wrote
//     the original software. If you use this software in a product, an acknowledgment in the
//     product documentation would be appreciated but is not required.
//
//  2. Altered source versions must be plainly marked as such, and must not be misrepresented as
//     being the original software.
//
//  3. This notice may not be removed or altered from any source distribution.
//--------------------------------------------------------------------------------------------------
 
#ifndef BUILDCACHE_FILE_LOCK_HPP_
#define BUILDCACHE_FILE_LOCK_HPP_
 
#include <string>
 
namespace bcache {
namespace file {
class file_lock_t {
public:
  file_lock_t() {
  }
 
  explicit file_lock_t(const std::string& path, const bool remote_lock);
 
  // Support move semantics.
  file_lock_t(file_lock_t&& other) noexcept;
  file_lock_t& operator=(file_lock_t&& other) noexcept;
  file_lock_t(const file_lock_t& other) = delete;
  file_lock_t& operator=(const file_lock_t& other) = delete;
 
  ~file_lock_t();
 
  bool has_lock() const {
    return m_has_lock;
  }
 
private:
#if defined(_WIN32)
  // WIN32 API HANDLE type is void*.
  using file_handle_t = void*;
  using mutex_handle_t = void*;
#else
  // POSIX file descriptor type is int.
  using file_handle_t = int;
  using mutex_handle_t = void*;  // dummy
#endif
 
  static file_handle_t invalid_file_handle() {
#if defined(_WIN32)
    return reinterpret_cast<void*>(-1);  // INVALID_HANDLE_VALUE
#else
    return -1;
#endif
  }
 
  static mutex_handle_t invalid_mutex_handle() {
#if defined(_WIN32)
    return nullptr;
#else
    return nullptr;
#endif
  }
 
  std::string m_path;
  file_handle_t m_file_handle = invalid_file_handle();
  mutex_handle_t m_mutex_handle = invalid_mutex_handle();
  bool m_has_lock = false;
};
 
}  // namespace file
}  // namespace bcache
 
#endif  // BUILDCACHE_FILE_LOCK_HPP_