Start working on build system.

src/base/core/filesystem/File.cpp

@@ -0,0 +1,388 @@
+#include "File.h"
+
+//#include "FileLogger.h"
+#include "ByteUtils.h"
+#include "Directory.h"
+#include "Result.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+class FileImpl
+{
+public:
+    Status do_open(const FileSystemPath& path, File::AccessMode accessMode)
+    {
+        int flags{0};
+        if (accessMode == File::AccessMode::Read)
+        {
+            flags |= O_RDONLY;
+        }
+        else
+        {
+            flags |= O_WRONLY;
+            flags |= O_CREAT;
+        }
+        errno = 0;
+        m_fd = ::open(path.str().raw(), flags);
+        if (m_fd < 0)
+        {
+            Status ret;
+            ret.on_errno("Failed to open file with");
+            return ret;
+        }
+
+        if (accessMode == File::AccessMode::Read)
+        {
+            m_open_for_read = true;
+        }
+        else
+        {
+            m_open_for_write = true;
+        }
+        return {};
+    }
+
+    Status do_close()
+    {
+        errno = 0;
+        const auto rc = ::close(m_fd);
+        if (rc < 0)
+        {
+            Status ret;
+            ret.on_errno("Failed to close file with");
+            return ret;          
+        }
+        m_open_for_read = false;
+        m_open_for_write = false;
+        return {};
+    }
+
+    bool is_ok() const
+    {
+        return m_valid;
+    }
+
+    bool is_open_for_read() const
+    {
+        return m_open_for_read;
+    }
+
+    bool is_open_for_write() const 
+    {
+        return m_open_for_write;
+    }
+
+    Result<std::size_t> do_read(VecBytes& bytes)
+    {
+        errno = 0;
+        const auto rc = ::read(m_fd, bytes.data(), bytes.capacity());
+        if (rc < 0)
+        {
+            const auto msg = _s("Error in read impl | ") + Error::from_errno();
+            return Result<std::size_t>(Error(msg));
+        }
+        return Result<std::size_t>(rc);
+    }
+
+    Result<std::size_t> do_write(const VecBytes& bytes)
+    {
+        errno = 0;
+        const auto rc = ::write(m_fd, bytes.data(), bytes.size());
+        if (rc < 0)
+        {
+            const auto msg = _s("Error in write impl | ") + Error::from_errno();
+            return Result<std::size_t>(Error(msg));
+        }   
+        return Result<std::size_t>(rc);
+    }
+
+    Result<std::size_t> do_write(const Vector<char>& bytes, int size = -1)
+    {
+        errno = 0;
+        int rc = 0;
+        if (size > -1)
+        {
+            rc = ::write(m_fd, bytes.data(), size);
+        }
+        else
+        {
+            rc = ::write(m_fd, bytes.data(), bytes.size());
+        }
+        if (rc < 0)
+        {
+            const auto msg = _s("Error in write impl | ") + Error::from_errno();
+            return Result<std::size_t>(Error(msg));
+        }   
+        return Result<std::size_t>(rc);   
+    }
+
+    Status update_size()
+    {
+        struct stat buf;
+        const auto rc = ::fstat(m_fd, &buf);
+        if (rc != 0)
+        {
+            Status ret;
+            ret.on_errno("Failed to get size with fstat");
+            return ret;        
+        }
+        m_size = buf.st_size;
+        return {};
+    }
+
+    bool m_open_for_write{false};
+    bool m_open_for_read{false};
+    bool m_valid{false};
+    std::size_t m_size{0};
+    bool m_is_open{false};
+    int m_fd{-1};
+};
+
+File::File(const FileSystemPath& path)
+    : m_impl(Ptr<FileImpl>::create()),
+      m_path(path)
+{
+}
+
+File::~File()
+{
+    close();
+}
+
+String File::getExtension() const
+{
+    return m_path.extension();
+}
+
+Status File::readBinary(VecBytes& buffer)
+{
+    auto status = open(AccessMode::Read, true);
+    if (!status.ok())
+    {
+        return status;
+    }
+
+    status = m_impl->update_size();
+    if (!status.ok())
+    {
+        return status;
+    }
+
+    buffer.resize(m_impl->m_size);
+    const auto result = m_impl->do_read(buffer);
+    if (!result.ok())
+    {
+        return Status(result.error());
+    }
+    buffer.resize(result.value());
+    return {};
+}
+
+Status File::readText(String& ret)
+{
+    auto status = open(AccessMode::Read, true);
+    if (!status.ok())
+    {
+        return status;
+    }
+
+    VecBytes buffer;
+    status = m_impl->update_size();
+    if (status.ok() && m_impl->m_size > 0)
+    {
+        buffer.resize(m_impl->m_size);
+        const auto result = m_impl->do_read(buffer);
+        if (!result.ok())
+        {
+            return Status(result.error());
+        }
+        buffer.resize(result.value());
+        ret.append(buffer);
+    }
+    else
+    {
+        buffer.resize(1024);
+        while(true)
+        {
+            const auto result = m_impl->do_read(buffer);
+            if (!result.ok())
+            {
+                return Status(result.error());
+            }
+            if (result.value() < 1024)
+            {
+                if (result.value() > 0)
+                {
+                    buffer.resize(result.value());
+                    ret.append(buffer);
+                }
+                break;
+            }
+            else
+            {
+                ret.append(buffer);
+            }
+        }
+    }
+    return {};
+}
+
+String File::dumpBinary()
+{
+    open(AccessMode::Read);
+
+    String sstr;
+    sstr << "Count | Binary | Decimal | Hex | ASCII \n";
+    
+    VecBytes buffer;
+    readBinary(buffer);
+
+    unsigned count = 0;
+    /*
+    for(const auto byte : buffer)
+    {
+        const auto ascii_val = std::isalpha(byte) ? byte : '.';
+        String hex_sstr;
+        hex_sstr << std::setfill('0') << std::setw(2) << std::hex << static_cast<int>(byte);
+
+        sstr << count << " | " << ByteUtils::toString(byte) << " | " << static_cast<int>(byte) << " | " << hex_sstr.str() << " | " << ascii_val << '\n';
+        if (count % 10 == 0)
+        {
+            sstr << "\n";
+        }
+        count++;
+    }
+    */
+    close();
+    return sstr;
+}
+
+Optional<Byte> File::readNextByte()
+{
+    if (!open(AccessMode::Read).ok())
+    {
+        return {};
+    }
+
+    if (m_impl->is_ok())
+    {
+        VecBytes buffer(1);
+        m_impl->do_read(buffer);
+        if (buffer[0] == EOF)
+        {
+            return {};
+        }
+        else
+        {
+            return buffer[0];
+        }
+    }
+    else
+    {
+        return {};
+    }
+}
+
+Status File::open(AccessMode accessMode, bool binary)
+{
+    if (m_path.is_absolute() && !m_path.parent_path().exists())
+    {
+        Directory::create(m_path.parent_path(), true);
+    }
+
+    return m_impl->do_open(m_path, accessMode);
+}
+
+Status File::close()
+{
+    return m_impl->do_close();
+}
+
+FileFormat::Format File::inferFormat() const
+{
+    //const auto extension = getExtension();
+    //return FileFormat::inferFormat(extension);
+    return {};
+}
+
+Status File::writeText(const String& text)
+{
+    bool had_to_open{false};
+    Status status;
+    if (!m_impl->is_open_for_write())
+    {
+        had_to_open = true;
+        status = m_impl->do_open(m_path, File::AccessMode::Write);
+        if (!status.ok())
+        {
+            return status;
+        }
+    }
+    const auto result = m_impl->do_write(text.data(), text.data().size() - 1);
+    if (!result.ok())
+    {
+        return Status(result.error());
+    }
+
+    if (had_to_open)
+    {
+        status = m_impl->do_close();
+    }
+    return status;
+}
+
+Status File::readLines(Vector<String>& lines)
+{
+    /*
+    if (!pathExists())
+    {
+        return {};
+    }
+
+    if(!open(AccessMode::Read))
+    {
+        return {};
+    }
+
+    String str;
+    while(std::getline(*mInHandle, str))
+    {
+        content.push_back(str);
+    }
+
+    close();
+    */
+    return {};
+}
+
+Status File::read(String& ret)
+{
+    /*
+    if (!pathExists())
+    {
+        return {};
+    }
+
+    if(!open(AccessMode::Read))
+    {
+        return {};
+    }
+
+    String buffer;
+    buffer << mInHandle->rdbuf();
+
+    close();
+    */
+    return {};
+}
+
+bool File::exists() const
+{
+    return m_path.exists();
+}