be_io_utility.h

Go to the documentation of this file.

/******************************************************************************
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 ******************************************************************************/
#ifndef __BE_IO_UTILITY_H
#define __BE_IO_UTILITY_H
 
#include <sys/stat.h>
 
#include <cstdint>
#include <fstream>
#include <string>
 
#include <be_error_exception.h>
#include <be_memory_autoarray.h>
#include <be_sysdeps.h>
 
namespace BiometricEvaluation
{
        namespace IO
        {
                namespace Utility {
                        
                        void removeDirectory(
                            const std::string &directory,
                            const std::string &prefix);
 
                        void removeDirectory(
                            const std::string &pathname);
 
                        void copyDirectoryContents(
                            const std::string &sourcepath,
                            const std::string &targetpath,
                            const bool removesource = false);
 
                        void setAsideName(
                            const std::string &name);
 
                        uint64_t getFileSize(
                            const std::string &pathname);
 
                        uint64_t
                        sumDirectoryUsage(const std::string &pathname);
 
                        bool fileExists(
                            const std::string &pathname);
 
                        /*
                         * Indicate whether a path points to a directory.
                         *
                         * @param[in] pathname
                         *      The path to be checked
                         * @return
                         *      true if the path is a dir, false otherwise.
                         * @throw Error::StrategyError
                         *              An error occurred when using the
                         *              underlying storage system, or the
                         *              name is malformed.
                         */
                        bool pathIsDirectory(
                            const std::string &pathname);
 
                        int makePath(const std::string &path, const mode_t mode);
                        
                        Memory::uint8Array
                        readFile(
                            const std::string &path,
                            std::ios_base::openmode mode = std::ios_base::binary);
                        
                        void
                        writeFile(
                            const uint8_t *data,
                            const size_t size,
                            const std::string &path,
                            std::ios_base::openmode mode = std::ios_base::binary);
 
                        void
                        writeFile(
                            const Memory::uint8Array data,
                            const std::string &path,
                            std::ios_base::openmode mode = std::ios_base::binary);
 
                        void
                        readPipe(
                            void *data,
                            size_t size,
                            int pipeFD);
 
                        void
                        readPipe(
                            Memory::uint8Array &data,
                            int pipeFD);
 
                        void
                        writePipe(
                            const void *data,
                            size_t size,
                            int pipeFD);
 
                        void
                        writePipe(
                            const Memory::uint8Array &data,
                            int pipeFD);
 
                        bool
                        isReadable(
                            const std::string &pathname);
                        
                        bool
                        isWritable(
                            const std::string &pathname);
                            
                        std::string
                        createTemporaryFile(
                            const std::string &prefix = "",
                            const std::string &parentDir = "/tmp");
                            
                        FILE*
                        createTemporaryFile(
                            std::string &path,
                            const std::string &prefix = "",
                            const std::string &parentDir = "/tmp");
                        
                        uint64_t
                        countLines(
                            const std::string &path);
 
                        uint64_t
                        countLines(
                            const Memory::uint8Array &textBuffer);
                }
        }
}
#endif  /* __BE_IO_UTILITY_H */