THUAI6/CAPI/cpp/grpc/include/upb/upb.hpp

// Copyright (c) 2009-2021, Google LLC
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of Google LLC nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef UPB_HPP_
#define UPB_HPP_

#include <memory>

#include "upb/upb.h"

namespace upb
{

    class Status
    {
    public:
        Status()
        {
            upb_Status_Clear(&status_);
        }

        upb_Status* ptr()
        {
            return &status_;
        }

        // Returns true if there is no error.
        bool ok() const
        {
            return upb_Status_IsOk(&status_);
        }

        // Guaranteed to be NULL-terminated.
        const char* error_message() const
        {
            return upb_Status_ErrorMessage(&status_);
        }

        // The error message will be truncated if it is longer than
        // _kUpb_Status_MaxMessage-4.
        void SetErrorMessage(const char* msg)
        {
            upb_Status_SetErrorMessage(&status_, msg);
        }
        void SetFormattedErrorMessage(const char* fmt, ...)
        {
            va_list args;
            va_start(args, fmt);
            upb_Status_VSetErrorFormat(&status_, fmt, args);
            va_end(args);
        }

        // Resets the status to a successful state with no message.
        void Clear()
        {
            upb_Status_Clear(&status_);
        }

    private:
        upb_Status status_;
    };

    class Arena
    {
    public:
        // A simple arena with no initial memory block and the default allocator.
        Arena() :
            ptr_(upb_Arena_New(), upb_Arena_Free)
        {
        }
        Arena(char* initial_block, size_t size) :
            ptr_(upb_Arena_Init(initial_block, size, &upb_alloc_global), upb_Arena_Free)
        {
        }

        upb_Arena* ptr()
        {
            return ptr_.get();
        }

        // Allows this arena to be used as a generic allocator.
        //
        // The arena does not need free() calls so when using Arena as an allocator
        // it is safe to skip them.  However they are no-ops so there is no harm in
        // calling free() either.
        upb_alloc* allocator()
        {
            return upb_Arena_Alloc(ptr_.get());
        }

        // Add a cleanup function to run when the arena is destroyed.
        // Returns false on out-of-memory.
        template<class T>
        bool Own(T* obj)
        {
            return upb_Arena_AddCleanup(ptr_.get(), obj, [](void* obj)
                                        { delete static_cast<T*>(obj); });
        }

        void Fuse(Arena& other)
        {
            upb_Arena_Fuse(ptr(), other.ptr());
        }

    private:
        std::unique_ptr<upb_Arena, decltype(&upb_Arena_Free)> ptr_;
    };

    // InlinedArena seeds the arenas with a predefined amount of memory.  No
    // heap memory will be allocated until the initial block is exceeded.
    template<int N>
    class InlinedArena : public Arena
    {
    public:
        InlinedArena() :
            Arena(initial_block_, N)
        {
        }

    private:
        InlinedArena(const InlinedArena*) = delete;
        InlinedArena& operator=(const InlinedArena*) = delete;

        char initial_block_[N];
    };

}  // namespace upb

#endif  // UPB_HPP_