outputHandlerPosixFile.h

Go to the documentation of this file.

#ifndef __outputHandlerPosixFile_h__
#define __outputHandlerPosixFile_h__
#include "outputHandler.h"
#include "posixFileCommon.h"
#include <sys/stat.h>
#include <sys/types.h>
 
namespace outputHandler {
 
    class posixFile: public base, virtual public posixFileCommon {
        static factoryTemplate<posixFile> factory;
      public:
        class writerPosixFile: public outputHandler::base::writer, virtual public posixFileIoCommon {
          protected:
            struct stat writeInitialStat;
            std::unique_ptr<ioHandle::attrDataType> attrData;
            std::unique_ptr<acl::list> aclData;
          public:
            writerPosixFile(const std::string& aPath,
                            bool mightAppend,
                            size_t sourceSize,
                            size_t readBlockSize,
                            copyRequest::stateType &state,
                            bool noWrite,
                            std::unique_ptr<ioHandle::attrDataType> aAttrData,
                            std::unique_ptr<acl::list> aAclData);
            writerPosixFile(std::string& aPath,
                            bool noWrite,
                            std::unique_ptr<ioHandle::attrDataType> aAttrData,
                            std::unique_ptr<acl::list> aAclData,
                            base& handler);
            void closeAndRemoveBadCopy() override;
            ~writerPosixFile() noexcept(false) override;
            void seek(size_t position) override;
            bool parallelizable() const override;
            size_t getSize() const override;
            void writeBlock(const block& b) override;
            void writeBlockP(const block& b) override;
            void doAttributePreservations(const genericStat& readInitialStat) override;
            void sync() override;
        };
        posixFile() = default;
        ~posixFile() override = default;
        std::unique_ptr<writer> newWriter(const std::string& path,
                                          bool mightAppend,
                                          size_t sourceSize,
                                          size_t readBlockSize,
                                          copyRequest::stateType &state,
                                          bool noWrite,
                                          std::unique_ptr<ioHandle::attrDataType> attrData,
                                          std::unique_ptr<acl::list> aclData) override;
        std::unique_ptr<writer> newTmpWriter(std::string& path,
                                             size_t sourceSize,
                                             bool noWrite,
                                             std::unique_ptr<ioHandle::attrDataType> attrData,
                                             std::unique_ptr<acl::list> aclData) override;
        void ensureParentDirs(const std::string& path,
                              const std::string& srcPath,
                              inputHandler::base* InputHandler) override;
        void remove(const std::string& path, copyRequest::stateType& state) override;
        bool renameSimple(const std::string& fromPath,
                          const std::string& toPath) override;
        base::renameRetvalType rename(const std::string& fromPath,
                                      const std::unique_ptr<const genericStat>& readInitialStat,
                                      const std::string& toPath,
                                      copyRequest::stateType& state) override;
        void createSymlink(const std::vector<char>& target,
                           const std::string& path,
                           uid_t uid, gid_t gid) override;
        void doAttributePreservations(const std::string& path,
                                      const genericStat& stat) override;
        size_t getMaxNameLength(const std::string& dirPath) override;
    };
}; // end namespace outputHandler
 
 
#endif