NameBuffer.h

Go to the documentation of this file.

#pragma once

#include "Types.h"
#include "Error.h"

namespace IFS
{
struct NameBuffer {
    char* buffer{nullptr}; 
    uint16_t size{0};     
    uint16_t length{0}; 

    NameBuffer()
    {
    }

    NameBuffer(char* buffer, uint16_t size, uint16_t length = 0) : buffer(buffer), size(size), length(length)
    {
    }

    NameBuffer(String& s) : buffer(s.begin()), size(s.length()), length(s.length())
    {
    }

    operator const char*() const
    {
        return buffer;
    }

    char* begin()
    {
        return buffer;
    }

    const char* c_str() const
    {
        return buffer;
    }

    explicit operator String() const
    {
        return String(buffer, length);
    }

    int copy(const char* src, uint16_t srclen)
    {
        length = srclen;
        uint16_t copylen = std::min(srclen, size);
        if(copylen != 0) {
            memcpy(buffer, src, copylen);
        }
        terminate();
        return (copylen == srclen) ? FS_OK : Error::BufferTooSmall;
    }

    int copy(const char* src)
    {
        return copy(src, strlen(src));
    }

    int copy(const NameBuffer& name)
    {
        return copy(name.buffer, name.length);
    }

    int addSep()
    {
        // No separator required if path is empty
        if(length == 0) {
            return FS_OK;
        }

        if(length + 1 < size) {
            buffer[length++] = '/';
            buffer[length] = '\0';
            return FS_OK;
        }

        ++length;
        return Error::BufferTooSmall;
    }

    char* endptr()
    {
        return buffer + length;
    }

    uint16_t space()
    {
        return (length < size) ? size - length : 0;
    }

    void terminate()
    {
        if(length < size) {
            buffer[length] = '\0';
        } else if(size != 0) {
            buffer[size - 1] = '\0';
        }
    }

    bool overflow() const
    {
        return length >= size;
    }
};

struct FileNameBuffer : public NameBuffer {
public:
    FileNameBuffer() : NameBuffer(buffer, sizeof(buffer))
    {
    }

private:
    // maximum size for a byte-length string, + 1 char for nul terminator
    char buffer[256];
};

} // namespace IFS