file.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_FILE_H
#define RUDIMENTS_FILE_H
 
#include <rudiments/private/fileincludes.h>
 
class RUDIMENTS_DLLSPEC file : public filedescriptor {
        public:
 
                file();
 
                virtual ~file();
 
                virtual bool    open(const char *name, int32_t flags);
 
                virtual bool    open(const char *name,
                                                int32_t flags,
                                                mode_t perms);
 
                virtual bool    create(const char *name, mode_t perms);
 
 
                virtual char    *getContents();
 
                virtual ssize_t getContents(byte_t *buffer,
                                                        size_t buffersize);
 
                virtual ssize_t getContents(byte_t **buffer,
                                                        size_t *buffersize);
 
                virtual bool    truncate();
 
                virtual bool    truncate(off64_t size);
 
 
                virtual bool    tryLockFile(int16_t type);
 
                virtual bool    lockFile(int16_t type);
 
                virtual bool    checkLockFile(int16_t type,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    unlockFile();
 
                virtual bool    tryLockRegion(int16_t type,
                                                off64_t start,
                                                off64_t len);
 
                virtual bool    lockRegion(int16_t type,
                                                off64_t start,
                                                off64_t len);
 
                virtual bool    checkLockRegion(int16_t type,
                                                off64_t start,
                                                off64_t len,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    unlockRegion(off64_t start,
                                                off64_t len);
 
                virtual bool    tryLockFromCurrent(int16_t type,
                                                        off64_t len);
 
                virtual bool    tryLockFromCurrent(int16_t type,
                                                        off64_t start,
                                                        off64_t len);
 
                virtual bool    lockFromCurrent(int16_t type,
                                                        off64_t len);
 
                virtual bool    lockFromCurrent(int16_t type,
                                                        off64_t start,
                                                        off64_t len);
 
                virtual bool    checkLockFromCurrent(int16_t type,
                                                        off64_t len,
                                                        int16_t *conftype,
                                                        int16_t *confwhence,
                                                        off64_t *confstart,
                                                        off64_t *conflen);
 
                virtual bool    checkLockFromCurrent(int16_t type,
                                                        off64_t start,
                                                        off64_t len,
                                                        int16_t *conftype,
                                                        int16_t *confwhence,
                                                        off64_t *confstart,
                                                        off64_t *conflen);
 
                virtual bool    unlockFromCurrent(off64_t len);
 
                virtual bool    unlockFromCurrent(off64_t start,
                                                        off64_t len);
 
                virtual bool    tryLockFromEnd(int16_t type,
                                                        off64_t len);
 
                virtual bool    tryLockFromEnd(int16_t type,
                                                        off64_t start,
                                                        off64_t len);
 
                virtual bool    lockFromEnd(int16_t type, off64_t len);
 
                virtual bool    lockFromEnd(int16_t type,
                                                        off64_t start,
                                                        off64_t len);
 
                virtual bool    checkLockFromEnd(int16_t type,
                                                        off64_t len,
                                                        int16_t *conftype,
                                                        int16_t *confwhence,
                                                        off64_t *confstart,
                                                        off64_t *conflen);
 
                virtual bool    checkLockFromEnd(int16_t type,
                                                        off64_t start,
                                                        off64_t len,
                                                        int16_t *conftype,
                                                        int16_t *confwhence,
                                                        off64_t *confstart,
                                                        off64_t *conflen);
 
                virtual bool    unlockFromEnd(off64_t len);
 
                virtual bool    unlockFromEnd(off64_t start,
                                                        off64_t len);
 
                virtual bool    tryLockRemainder(int16_t type,
                                                        off64_t start);
 
                virtual bool    lockRemainder(int16_t type,
                                                        off64_t start);
 
                virtual bool    checkLockRemainder(int16_t type,
                                                        off64_t start,
                                                        int16_t *conftype,
                                                        int16_t *confwhence,
                                                        off64_t *confstart,
                                                        off64_t *conflen);
 
                virtual bool    unlockRemainder(off64_t start);
 
                virtual bool    tryLockRemainderFromCurrent(int16_t type);
 
                virtual bool    tryLockRemainderFromCurrent(int16_t type,
                                                        off64_t start);
 
                virtual bool    lockRemainderFromCurrent(int16_t type);
 
                virtual bool    lockRemainderFromCurrent(int16_t type,
                                                        off64_t start);
 
                virtual bool    checkLockRemainderFromCurrent(
                                                int16_t type,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    checkLockRemainderFromCurrent(
                                                int16_t type,
                                                off64_t start,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    unlockRemainderFromCurrent();
 
                virtual bool    unlockRemainderFromCurrent(off64_t start);
 
                virtual bool    tryLockRemainderFromEnd(int16_t type);
 
                virtual bool    tryLockRemainderFromEnd(int16_t type,
                                                        off64_t start);
 
                virtual bool    lockRemainderFromEnd(int16_t type);
 
                virtual bool    lockRemainderFromEnd(int16_t type,
                                                        off64_t start);
 
                virtual bool    checkLockRemainderFromEnd(
                                                int16_t type,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    checkLockRemainderFromEnd(
                                                int16_t type,
                                                off64_t start,
                                                int16_t *conftype,
                                                int16_t *confwhence,
                                                off64_t *confstart,
                                                off64_t *conflen);
 
                virtual bool    unlockRemainderFromEnd();
 
                virtual bool    unlockRemainderFromEnd(off64_t start);
 
 
                virtual bool    adviseSequentialAccess(off64_t start,
                                                        size_t len);
 
                virtual bool    adviseRandomAccess(off64_t start, size_t len);
 
                virtual bool    adviseOnlyOnce(off64_t start, size_t len);
 
                virtual bool    adviseWillNeed(off64_t start, size_t len);
 
                virtual bool    adviseWontNeed(off64_t start, size_t len);
 
                virtual bool    adviseNormalAccess(off64_t start, size_t len);
 
 
                virtual bool    reserve(off64_t start, size_t len);
 
 
                virtual bool    sync();
 
                virtual bool    syncData();
 
 
                virtual void    setGetCurrentPropertiesOnOpen(bool set);
 
                virtual bool    getCurrentProperties();
 
                virtual mode_t          getPermissions();
 
                virtual uid_t           getOwnerUserId();
 
                virtual gid_t           getOwnerGroupId();
 
                virtual off64_t         getSize();
 
                virtual blksize_t       getBlockSize();
 
                virtual blkcnt_t        getBlockCount();
 
                virtual int32_t         isSocket();
 
                virtual int32_t         isSymbolicLink();
 
                virtual int32_t         isRegularFile();
 
                virtual int32_t         isBlockDevice();
 
                virtual int32_t         isDirectory();
 
                virtual int32_t         isCharacterDevice();
 
                virtual int32_t         isFifo();
 
                virtual time_t          getLastAccessTime();
 
                virtual time_t          getLastModificationTime();
 
                virtual time_t          getLastChangeTime();
 
                virtual dev_t           getDevice();
 
                virtual dev_t           getDeviceType();
 
                virtual uint64_t        getInode();
 
                virtual nlink_t         getNumberOfHardLinks();
 
 
                virtual bool    setPermissions(mode_t perms);
 
 
                virtual bool    changeOwner(const char *newuser,
                                                const char *newgroup);
 
                virtual bool    changeOwner(uid_t uid, gid_t gid);
 
                virtual bool    getCanChangeOwner();
 
                virtual int64_t getMaxLinks();
 
 
                virtual void    *getInternalFileStatisticsStructure();
 
 
                static bool     createFile(const char *name, mode_t perms);
 
                static bool     createFifo(const char *filename, mode_t perms);
 
                static int32_t  createTemporaryFile(char *templatefilename);
 
                static int32_t  createTemporaryFile(char *templatefilename,
                                                                mode_t perms);
 
                static bool     createHardLink(const char *oldpath,
                                                        const char *newpath);
 
                static bool     createSymbolicLink(const char *oldpath,
                                                        const char *newpath);
 
                static char     *resolveSymbolicLink(const char *filename);
 
 
                static bool     rename(const char *oldpath,
                                        const char *newpath);
 
                static bool     remove(const char *filename);
 
 
                static  bool    truncate(const char *filename);
 
                static  bool    truncate(const char *filename, off64_t size);
 
 
                static  char    *getContents(const char *name);
 
                static  ssize_t getContents(const char *name,
                                                byte_t *buffer,
                                                size_t buffersize);
 
                virtual ssize_t getContents(const char *name,
                                                byte_t **buffer,
                                                size_t *buffersize);
 
 
                static bool     exists(const char *filename);
 
                static bool     isReadable(const char *filename);
 
                static bool     isWriteable(const char *filename);
 
                static bool     isExecutable(const char *filename);
 
                static bool     isAccessible(const char *filename,
                                                        int32_t mode);
 
                static bool     getLastChangeTime(const char *filename,
                                                        time_t *ctime);
 
                static bool     setPermissions(const char *filename,
                                                        mode_t perms);
 
                static bool     changeOwner(const char *filename,
                                                const char *newuser,
                                                const char *newgroup);
 
                static bool     changeOwner(const char *filename,
                                                uid_t uid, gid_t gid);
 
                static bool     getCanChangeOwner(const char *filename);
 
 
                static bool     setLastAccessTime(const char *filename,
                                                        time_t lastaccesstime);
 
                static bool     setLastModificationTime(const char *filename,
                                                        time_t lastmodtime);
 
                static bool     setLastAccessAndModificationTimes(
                                                        const char *filename,
                                                        time_t lastaccesstime,
                                                        time_t lastmodtime);
 
                static bool     setLastAccessAndModificationTimes(
                                                        const char *filename);
 
 
                static char     *getDirName(const char *filename);
 
                static char     *getBaseName(const char *filename);
 
                static char     *getBaseName(const char *filename,
                                                const char *ext);
 
                static char     *getExtension(const char *filename);
 
                static char     *getEightDotThree(const char *filename);
 
 
                static key_t    generateKey(const char *filename, int32_t id);
 
                static int64_t  getMaxLinks(const char *filename);
 
                static bool     getMatchingFileNames(
                                        const char *pattern,
                                        linkedlist<char *> *matches);
 
                static bool     getMatchingFileNames(
                                        const char * const *patterns,
                                        linkedlist<char *> *matches);
 
                static bool     getMatchingFileNames(
                                        linkedlist<const char *> *patterns,
                                        linkedlist<char *> *matches);
 
                static bool     getMatchingFileNames(
                                        linkedlist<char *> *patterns,
                                        linkedlist<char *> *matches);
 
        #include <rudiments/private/file.h>
};
 
#endif