FileLock.hxx

#pragma once
 
// Linux
#include <fcntl.h>
 
// cosmos
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/memory.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
 
class FileLock :
                public flock {
public: // types
 
        enum class Type : short {
                READ_LOCK  = F_RDLCK,
                WRITE_LOCK = F_WRLCK,
                UNLOCK     = F_UNLCK
        };
 
        // note: although the basic constants are the same, a different base
        // type is used in StreamIO::SeekType, so use a dedicated enum type
        // here.
        enum class SeekDir : short {
                SET = SEEK_SET,
                CUR = SEEK_CUR,
                END = SEEK_END
        };
 
public: // functions
 
        explicit FileLock(const Type type, const SeekDir dir = SeekDir::SET) {
                clear(type, dir);
        }
 
        void clear(const Type type, const SeekDir dir = SeekDir::SET) {
                zero_object(static_cast<flock&>(*this));
                setType(type);
                setWhence(dir);
        }
 
        Type type() const {
                return Type{this->l_type};
        }
 
        void setType(const Type type) {
                this->l_type = cosmos::to_integral(type);
        }
 
        SeekDir whence() const {
                return SeekDir{this->l_whence};
        }
 
        void setWhence(const SeekDir dir) {
                this->l_whence = cosmos::to_integral(dir);
        }
 
        off_t start() const {
                return this->l_start;
        }
 
        void setStart(const off_t start) {
                this->l_start = start;
        }
 
        off_t length() const {
                return this->l_len;
        }
 
        void setLength(const off_t len) {
                this->l_len = len;
        }
 
        ProcessID pid() const {
                return ProcessID{this->l_pid};
        }
 
        void clearPID() {
                this->l_pid = 0;
        }
 
 
        bool isOFDLock() const {
                return pid() == ProcessID::INVALID;
        }
};
 
 
struct COSMOS_API FileLockGuard {
 
        FileLockGuard(FileDescriptor fd, const FileLock &lock);
 
        ~FileLockGuard() {
                m_lock.setType(FileLock::Type::UNLOCK);
                m_fd.setOFDLockWait(m_lock);
        }
 
protected: // data
 
        FileDescriptor m_fd;
        FileLock m_lock;
};
 
} // end ns