Merge branch 'master' into stable

1 files changed, 300 insertions, 0 deletions

diff --git a/src/file_reader.hpp b/src/file_reader.hpp
new file mode 100644
index 0000000..7d13262
--- /dev/null
+++ b/src/file_reader.hpp
@@ -0,0 +1,300 @@
+/*
+ * FileAndMemoryReader - a tiny helper to utify file reading from a disk and memory block
+ *
+ * Copyright (c) 2015-2018 Vitaly Novichkov <admin@wohlnet.ru>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+#ifndef FILE_AND_MEM_READER_HHHH
+#define FILE_AND_MEM_READER_HHHH
+
+#include <string> // std::string
+#include <cstdio> // std::fopen, std::fread, std::fseek, std::ftell, std::fclose, std::feof
+#include <stdint.h> // uint*_t
+#include <stddef.h> // size_t and friends
+#ifdef _WIN32
+#define NOMINMAX 1
+#include <cstring> // std::strlen
+#include <windows.h> // MultiByteToWideChar
+#endif
+
+/**
+ * @brief A little class gives able to read filedata from disk and also from a memory segment
+ */
+class FileAndMemReader
+{
+    //! Currently loaded filename (empty for a memory blocks)
+    std::string m_file_name;
+    //! File reader descriptor
+    std::FILE   *m_fp;
+
+    //! Memory pointer descriptor
+    const void  *m_mp;
+    //! Size of memory block
+    size_t      m_mp_size;
+    //! Cursor position in the memory block
+    size_t      m_mp_tell;
+
+public:
+    /**
+     * @brief Relation direction
+     */
+    enum relTo
+    {
+        //! At begin position
+        SET = SEEK_SET,
+        //! At current position
+        CUR = SEEK_CUR,
+        //! At end position
+        END = SEEK_END
+    };
+
+    /**
+     * @brief C.O.: It's a constructor!
+     */
+    FileAndMemReader() :
+        m_fp(NULL),
+        m_mp(NULL),
+        m_mp_size(0),
+        m_mp_tell(0)
+    {}
+
+    /**
+     * @brief C.O.: It's a destructor!
+     */
+    ~FileAndMemReader()
+    {
+        close();
+    }
+
+    /**
+     * @brief Open file from a disk
+     * @param path Path to the file in UTF-8 (even on Windows!)
+     */
+    void openFile(const char *path)
+    {
+        if(m_fp)
+            this->close();//Close previously opened file first!
+#if !defined(_WIN32) || defined(__WATCOMC__)
+        m_fp = std::fopen(path, "rb");
+#else
+        wchar_t widePath[MAX_PATH];
+        int size = MultiByteToWideChar(CP_UTF8, 0, path, static_cast<int>(std::strlen(path)), widePath, MAX_PATH);
+        widePath[size] = '\0';
+        m_fp = _wfopen(widePath, L"rb");
+#endif
+        m_file_name = path;
+        m_mp = NULL;
+        m_mp_size = 0;
+        m_mp_tell = 0;
+    }
+
+    /**
+     * @brief Open file from memory block
+     * @param mem Pointer to the memory block
+     * @param lenght Size of given block
+     */
+    void openData(const void *mem, size_t lenght)
+    {
+        if(m_fp)
+            this->close();//Close previously opened file first!
+        m_fp = NULL;
+        m_mp = mem;
+        m_mp_size = lenght;
+        m_mp_tell = 0;
+    }
+
+    /**
+     * @brief Seek to given position
+     * @param pos Offset or position
+     * @param rel_to Relation (at begin, at current, or at end)
+     */
+    void seek(long pos, int rel_to)
+    {
+        if(!this->isValid())
+            return;
+
+        if(m_fp)//If a file
+        {
+            std::fseek(m_fp, pos, rel_to);
+        }
+        else//If a memory block
+        {
+            switch(rel_to)
+            {
+            case SET:
+                m_mp_tell = static_cast<size_t>(pos);
+                break;
+
+            case END:
+                m_mp_tell = m_mp_size - static_cast<size_t>(pos);
+                break;
+
+            case CUR:
+                m_mp_tell = m_mp_tell + static_cast<size_t>(pos);
+                break;
+            }
+
+            if(m_mp_tell > m_mp_size)
+                m_mp_tell = m_mp_size;
+        }
+    }
+
+    /**
+     * @brief Seek to given position (unsigned integer 64 as relation. Negative values not supported)
+     * @param pos Offset or position
+     * @param rel_to Relation (at begin, at current, or at end)
+     */
+    inline void seeku(uint64_t pos, int rel_to)
+    {
+        this->seek(static_cast<long>(pos), rel_to);
+    }
+
+    /**
+     * @brief Read the buffer from a file
+     * @param buf Pointer to the destination memory block
+     * @param num Number of elements
+     * @param size Size of one element
+     * @return Size
+     */
+    size_t read(void *buf, size_t num, size_t size)
+    {
+        if(!this->isValid())
+            return 0;
+        if(m_fp)
+            return std::fread(buf, num, size, m_fp);
+        else
+        {
+            size_t pos = 0;
+            size_t maxSize = static_cast<size_t>(size * num);
+
+            while((pos < maxSize) && (m_mp_tell < m_mp_size))
+            {
+                reinterpret_cast<uint8_t *>(buf)[pos] = reinterpret_cast<const uint8_t *>(m_mp)[m_mp_tell];
+                m_mp_tell++;
+                pos++;
+            }
+
+            return pos / num;
+        }
+    }
+
+    /**
+     * @brief Get one byte and seek forward
+     * @return Readed byte or EOF (a.k.a. -1)
+     */
+    int getc()
+    {
+        if(!this->isValid())
+            return -1;
+        if(m_fp)//If a file
+        {
+            return std::getc(m_fp);
+        }
+        else  //If a memory block
+        {
+            if(m_mp_tell >= m_mp_size)
+                return -1;
+            int x = reinterpret_cast<const uint8_t *>(m_mp)[m_mp_tell];
+            m_mp_tell++;
+            return x;
+        }
+    }
+
+    /**
+     * @brief Returns current offset of cursor in a file
+     * @return Offset position
+     */
+    size_t tell()
+    {
+        if(!this->isValid())
+            return 0;
+        if(m_fp)//If a file
+            return static_cast<size_t>(std::ftell(m_fp));
+        else//If a memory block
+            return m_mp_tell;
+    }
+
+    /**
+     * @brief Close the file
+     */
+    void close()
+    {
+        if(m_fp)
+            std::fclose(m_fp);
+
+        m_fp = NULL;
+        m_mp = NULL;
+        m_mp_size = 0;
+        m_mp_tell = 0;
+    }
+
+    /**
+     * @brief Is file instance valid
+     * @return true if vaild
+     */
+    bool isValid()
+    {
+        return (m_fp) || (m_mp);
+    }
+
+    /**
+     * @brief Is End Of File?
+     * @return true if end of file was reached
+     */
+    bool eof()
+    {
+        if(!this->isValid())
+            return true;
+        if(m_fp)
+            return (std::feof(m_fp) != 0);
+        else
+            return m_mp_tell >= m_mp_size;
+    }
+
+    /**
+     * @brief Get a current file name
+     * @return File name of currently loaded file
+     */
+    const std::string &fileName()
+    {
+        return m_file_name;
+    }
+
+    /**
+     * @brief Retrieve file size
+     * @return Size of file in bytes
+     */
+    size_t fileSize()
+    {
+        if(!this->isValid())
+            return 0;
+        if(!m_fp)
+            return m_mp_size; //Size of memory block is well known
+        size_t old_pos = this->tell();
+        seek(0l, FileAndMemReader::END);
+        size_t file_size = this->tell();
+        seek(static_cast<long>(old_pos), FileAndMemReader::SET);
+        return file_size;
+    }
+};
+
+#endif /* FILE_AND_MEM_READER_HHHH */