NameBuffer.h

Go to the documentation of this file.

/****
 * NameBuffer.h
 *
 * Created on: 31 Aug 2018
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the IFS Library
 *
 * This library 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, version 3 or later.
 *
 * This library 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 library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/
 
#pragma once
 
#include "Types.h"
#include "Error.h"
 
namespace IFS
{
struct NameBuffer {
    char* buffer{nullptr}; 
    uint16_t size{0};     
    uint16_t length{0}; 
 
    NameBuffer() = default;
 
    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);
    }
 
    bool operator==(const char* other)
    {
        return other != nullptr && strncmp(buffer, other, length) == 0;
    }
 
    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;
    }
 
    bool endsWith(const char* suffix) const
    {
        if(suffix == nullptr) {
            return false;
        }
        auto suffix_len = strlen(suffix);
        if(length < suffix_len || suffix_len == 0) {
            return false;
        }
        return memcmp(&buffer[length - suffix_len], suffix, suffix_len) == 0;
    }
};
 
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