basicio.hpp

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2018 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_