TidyBuffer.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  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 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  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, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * TidyBuffer.hpp
 *
 * RAII wrapper for tidyhtml buffers.
 *
 *  Created on: Feb 7, 2019
 *      Author: ans
 */

#ifndef WRAPPER_TIDYBUFFER_HPP_
#define WRAPPER_TIDYBUFFER_HPP_

#include <tidybuffio.h>

#include <cstddef>  // std::size_t
#include <string>   // std::string
#include <utility>  // std::move

namespace crawlservpp::Wrapper {

    /*
     * DECLARATION
     */


    class TidyBuffer {
    public:

        TidyBuffer() = default;

        virtual ~TidyBuffer();


        [[nodiscard]] ::TidyBuffer * get() noexcept;
        [[nodiscard]] const ::TidyBuffer * getc() const noexcept;
        [[nodiscard]] std::string getString() const noexcept;
        [[nodiscard]] bool valid() const noexcept;
        [[nodiscard]] std::size_t size() const noexcept;
        [[nodiscard]] bool empty() const noexcept;
        [[nodiscard]] std::size_t capacity() const noexcept;


        void clear() noexcept;



        TidyBuffer(const TidyBuffer& other);
        TidyBuffer& operator=(const TidyBuffer& other);
        TidyBuffer(TidyBuffer&& other) noexcept;
        TidyBuffer& operator=(TidyBuffer&& other) noexcept;


    private:
        ::TidyBuffer buffer{};
    };

    /*
     * IMPLEMENTATION
     */

    /*
     * CONSTRUCTION AND DESTRUCTION
     */

    inline TidyBuffer::~TidyBuffer() {
        this->clear();
    }

    /*
     * GETTERS
     */


    inline ::TidyBuffer * TidyBuffer::get() noexcept {
        return &(this->buffer);
    }


    inline const ::TidyBuffer * TidyBuffer::getc() const noexcept {
        return &(this->buffer);
    }


    inline std::string TidyBuffer::getString() const noexcept {
        if(this->buffer.bp == nullptr || this->buffer.size == 0) {
            return "";
        }

        return std::string(
                static_cast<const char *>(static_cast<void *>(this->buffer.bp)),
                this->buffer.size
        );
    }


    inline bool TidyBuffer::valid() const noexcept {
        return this->buffer.bp != nullptr;
    }


    inline std::size_t TidyBuffer::size() const noexcept {
        return this->buffer.size;
    }


    inline std::size_t TidyBuffer::capacity() const noexcept {
        return this->buffer.allocated;
    }


    inline bool TidyBuffer::empty() const noexcept {
        return this->buffer.bp == nullptr || this->buffer.size == 0;
    }

    /*
     * CLEANUP
     */


    inline void TidyBuffer::clear() noexcept {
        if(this->buffer.bp != nullptr) {
            tidyBufFree(&(this->buffer)); // (also sets buffer structure to zeroes)
        }
    }

    /*
     * COPY AND MOVE
     */


    inline TidyBuffer::TidyBuffer(const TidyBuffer& other) : buffer{} {
        if(other.valid()) {
            if(other.buffer.allocator != nullptr) {
                ::tidyBufAllocWithAllocator(
                        &(this->buffer),
                        other.buffer.allocator,
                        other.capacity()
                );
            }
            else {
                ::tidyBufAlloc(
                        &(this->buffer),
                        other.capacity()
                );
            }

            if(!other.empty()) {
                ::tidyBufAppend(
                        &(this->buffer),
                        other.buffer.bp,
                        other.size()
                );
            }
        }
    }


    inline TidyBuffer& TidyBuffer::operator=(const TidyBuffer& other) {
        if(this != &other) {
            // clear old buffer if necessary
            this->clear();

            if(other.valid()) {
                // allocate memory for the copy
                if(other.buffer.allocator != nullptr) {
                    ::tidyBufAllocWithAllocator(
                            &(this->buffer),
                            other.buffer.allocator,
                            other.capacity()
                    );
                }
                else {
                    ::tidyBufAlloc(
                            &(this->buffer),
                            other.capacity()
                    );
                }

                // copy the bytes
                if(!other.empty()) {
                    ::tidyBufAppend(
                            &(this->buffer),
                            other.buffer.bp,
                            other.size()
                    );
                }
            }
        }

        return *this;
    }


    inline TidyBuffer::TidyBuffer(TidyBuffer&& other) noexcept : buffer{} {
        this->buffer = other.buffer;

        other.buffer.allocator = nullptr;
        other.buffer.bp = nullptr;
        other.buffer.size = 0;
        other.buffer.allocated = 0;
        other.buffer.next = 0;
    }


    inline TidyBuffer& TidyBuffer::operator=(TidyBuffer&& other) noexcept {
        if(this != &other) {
            this->clear();

            this->buffer = other.buffer;

            other.buffer.allocator = nullptr;
            other.buffer.bp = nullptr;
            other.buffer.size = 0;
            other.buffer.allocated = 0;
            other.buffer.next = 0;
        }

        return *this;
    }

} /* namespace crawlservpp::Wrapper */

#endif /* WRAPPER_TIDYBUFFER_HPP_ */