basicio.hpp

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2021 Exiv2 authors
 * This program is part of the Exiv2 distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
 */
/*
  File:      basicio.hpp
 */
#ifndef BASICIO_HPP_
#define BASICIO_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "types.hpp"
 
// + standard includes
#include <memory>       // for std::auto_ptr
 
// The way to handle data from stdin or data uri path. If EXV_XPATH_MEMIO = 1,
// it uses MemIo. Otherwises, it uses FileIo.
#ifndef EXV_XPATH_MEMIO
#define EXV_XPATH_MEMIO 0
#endif
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
 
// *****************************************************************************
// class definitions
 
    class EXIV2API BasicIo {
    public:
        typedef std::auto_ptr<BasicIo> AutoPtr;
 
        enum Position { beg, cur, end };
 
 
 
        virtual ~BasicIo();
 
 
 
        virtual int open() = 0;
 
        virtual int close() = 0;
        virtual long write(const byte* data, long wcount) = 0;
        virtual long write(BasicIo& src) = 0;
        virtual int putb(byte data) = 0;
        virtual DataBuf read(long rcount) = 0;
        virtual long read(byte* buf, long rcount) = 0;
        virtual int getb() = 0;
        virtual void transfer(BasicIo& src) = 0;
#if defined(_MSC_VER)
        virtual int seek(int64_t offset, Position pos) = 0;
#else
        virtual int seek(long offset, Position pos) = 0;
#endif
 
        virtual byte* mmap(bool isWriteable =false) =0;
        virtual int munmap() =0;
 
 
 
 
        virtual long tell() const = 0;
        virtual size_t size() const = 0;
        virtual bool isopen() const = 0;
        virtual int error() const = 0;
        virtual bool eof() const = 0;
        virtual std::string path() const =0;
#ifdef EXV_UNICODE_PATH
        virtual std::wstring wpath() const =0;
#endif
 
        virtual void populateFakeData() {}
 
        byte* bigBlock_;
 
 
    protected:
 
 
        BasicIo() : bigBlock_(NULL) {};
    }; // class BasicIo
 
    class EXIV2API IoCloser {
    public:
 
 
        explicit IoCloser(BasicIo& bio) : bio_(bio) {}
        virtual ~IoCloser() { close(); }
 
 
 
        void close() { if (bio_.isopen()) bio_.close(); }
 
        // DATA
        BasicIo& bio_;
 
    private:
        // Not implemented
        IoCloser(const IoCloser&);
        IoCloser& operator=(const IoCloser&);
    }; // class IoCloser
 
    class EXIV2API FileIo : public BasicIo {
    public:
 
 
        explicit FileIo(const std::string& path);
#ifdef EXV_UNICODE_PATH
        FileIo(const std::wstring& wpath);
#endif
        virtual ~FileIo();
 
 
 
        int open(const std::string& mode);
        virtual int open();
        virtual int close();
        virtual long write(const byte* data, long wcount);
        virtual long write(BasicIo& src);
        virtual int putb(byte data);
        virtual DataBuf read(long rcount);
        virtual long read(byte* buf, long rcount);
        virtual int getb();
        virtual void transfer(BasicIo& src);
#if defined(_MSC_VER)
        virtual int seek(int64_t offset, Position pos);
#else
        virtual int seek(long offset, Position pos);
#endif
        virtual byte* mmap(bool isWriteable =false);
        virtual int munmap();
        virtual void setPath(const std::string& path);
#ifdef EXV_UNICODE_PATH
        virtual void setPath(const std::wstring& wpath);
#endif
 
 
        virtual long tell() const;
        virtual size_t size() const;
        virtual bool isopen() const;
        virtual int error() const;
        virtual bool eof() const;
        virtual std::string path() const;
#ifdef EXV_UNICODE_PATH
        /*
          @brief Like path() but returns the unicode path of the file in an std::wstring.
          @note This function is only available on Windows.
         */
        virtual std::wstring wpath() const;
#endif
 
        virtual void populateFakeData();
 
    private:
        // NOT IMPLEMENTED
        FileIo(FileIo& rhs);
        FileIo& operator=(const FileIo& rhs);
 
        // Pimpl idiom
        class Impl;
        std::auto_ptr<Impl> p_;
 
    }; // class FileIo
 
    class EXIV2API MemIo : public BasicIo {
    public:
 
 
        MemIo();
        MemIo(const byte* data, long size);
        virtual ~MemIo();
 
 
 
        virtual int open();
        virtual int close();
        virtual long write(const byte* data, long wcount);
        virtual long write(BasicIo& src);
        virtual int putb(byte data);
        virtual DataBuf read(long rcount);
        virtual long read(byte* buf, long rcount);
        virtual int getb();
        virtual void transfer(BasicIo& src);
#if defined(_MSC_VER)
        virtual int seek(int64_t offset, Position pos);
#else
        virtual int seek(long offset, Position pos);
#endif
        virtual byte* mmap(bool /*isWriteable*/ =false);
        virtual int munmap();
 
 
 
        virtual long tell() const;
        virtual size_t size() const;
        virtual bool isopen() const;
        virtual int error() const;
        virtual bool eof() const;
        virtual std::string path() const;
#ifdef EXV_UNICODE_PATH
        /*
          @brief Like path() but returns a unicode dummy path in an std::wstring.
          @note This function is only available on Windows.
         */
        virtual std::wstring wpath() const;
#endif
 
        virtual void populateFakeData();
 
 
    private:
        // NOT IMPLEMENTED
        MemIo(MemIo& rhs);
        MemIo& operator=(const MemIo& rhs);
 
        // Pimpl idiom
        class Impl;
        std::auto_ptr<Impl> p_;
 
    }; // class MemIo
 
#if EXV_XPATH_MEMIO
    class EXIV2API XPathIo : public MemIo {
    public:
 
 
        XPathIo(const std::string& path);
#ifdef EXV_UNICODE_PATH
        XPathIo(const std::wstring& wpath);
#endif
    private:
        void ReadStdin();
        void ReadDataUri(const std::string& path);
    }; // class XPathIo
#else
    class EXIV2API XPathIo : public FileIo {
    public:
        static const std::string TEMP_FILE_EXT;
        static const std::string GEN_FILE_EXT;
 
 
 
        explicit XPathIo(const std::string& orgPath);
#ifdef EXV_UNICODE_PATH
        XPathIo(const std::wstring& wOrgPathpath);
#endif
        virtual ~XPathIo();
 
 
 
        virtual void transfer(BasicIo& src);
 
 
 
 
        static std::string writeDataToFile(const std::string& orgPath);
#ifdef EXV_UNICODE_PATH
        static std::string writeDataToFile(const std::wstring& wOrgPath);
#endif
 
    private:
        // True if the file is a temporary file and it should be deleted in destructor.
        bool isTemp_;
        std::string tempFilePath_;
    }; // class XPathIo
#endif
 
 
    class EXIV2API RemoteIo : public BasicIo {
    public:
        virtual ~RemoteIo();
 
 
 
        virtual int open();
 
        virtual int close();
        virtual long write(const byte* data, long wcount);
        virtual long write(BasicIo& src);
 
       virtual int putb(byte data);
       virtual DataBuf read(long rcount);
       virtual long read(byte* buf, long rcount);
       virtual int getb();
       virtual void transfer(BasicIo& src);
#if defined(_MSC_VER)
       virtual int seek(int64_t offset, Position pos);
#else
       virtual int seek(long offset, Position pos);
#endif
       virtual byte* mmap(bool /*isWriteable*/ =false);
       virtual int munmap();
 
 
       virtual long tell() const;
       virtual size_t size() const;
       virtual bool isopen() const;
       virtual int error() const;
       virtual bool eof() const;
       virtual std::string path() const;
#ifdef EXV_UNICODE_PATH
       /*
         @brief Like path() but returns a unicode URL path in an std::wstring.
         @note This function is only available on Windows.
        */
       virtual std::wstring wpath() const;
#endif
 
       virtual void populateFakeData();
 
 
    protected:
 
 
        RemoteIo() {p_=NULL;}
 
        // Pimpl idiom
        class Impl;
        Impl* p_;
    }; // class RemoteIo
 
    class EXIV2API HttpIo : public RemoteIo {
    public:
 
 
        HttpIo(const std::string&  url,  size_t blockSize = 1024);
#ifdef EXV_UNICODE_PATH
        HttpIo(const std::wstring& wurl, size_t blockSize = 1024);
#endif
    protected:
        // NOT IMPLEMENTED
        HttpIo(HttpIo& rhs);
        HttpIo& operator=(const HttpIo& rhs);
        // Pimpl idiom
        class HttpImpl;
 
 
 
        virtual ~HttpIo(){}
    };
 
#ifdef EXV_USE_CURL
    class EXIV2API CurlIo : public RemoteIo {
    public:
 
 
        CurlIo(const std::string&  url,  size_t blockSize = 0);
#ifdef EXV_UNICODE_PATH
        CurlIo(const std::wstring& wurl, size_t blockSize = 0);
#endif
        long write(const byte* data, long wcount);
        long write(BasicIo& src);
    protected:
        // NOT IMPLEMENTED
        CurlIo(CurlIo& rhs);
        CurlIo& operator=(const CurlIo& rhs);
        // Pimpl idiom
        class CurlImpl;
 
 
 
        virtual ~CurlIo(){}
    };
#endif
 
#ifdef EXV_USE_SSH
    class EXIV2LIB_DEPRECATED_EXPORT SshIo : public RemoteIo {
    public:
 
 
        SshIo(const std::string&  url,  size_t blockSize = 1024);
#ifdef EXV_UNICODE_PATH
        SshIo(const std::wstring& wurl, size_t blockSize = 1024);
#endif
    protected:
        // NOT IMPLEMENTED
        SshIo(SshIo& rhs);
        SshIo& operator=(const SshIo& rhs);
        // Pimpl idiom
        class SshImpl;
 
 
 
        virtual ~SshIo(){}
    };
#endif
 
// *****************************************************************************
// template, inline and free functions
 
    EXIV2API DataBuf readFile(const std::string& path);
#ifdef EXV_UNICODE_PATH
    EXIV2API DataBuf readFile(const std::wstring& wpath);
#endif
    EXIV2API long writeFile(const DataBuf& buf, const std::string& path);
#ifdef EXV_UNICODE_PATH
    EXIV2API long writeFile(const DataBuf& buf, const std::wstring& wpath);
#endif
    EXIV2API std::string ReplaceStringInPlace(std::string subject, const std::string& search,
                          const std::string& replace);
#ifdef EXV_UNICODE_PATH
    EXIV2API std::wstring ReplaceStringInPlace(std::wstring subject, const std::wstring& search,
                          const std::wstring& replace);
#endif
#ifdef EXV_USE_CURL
    EXIV2API size_t curlWriter(char* data, size_t size, size_t nmemb, std::string* writerData);
#endif
}                                       // namespace Exiv2
#endif                                  // #ifndef BASICIO_HPP_