dynamic_protobuf_manager.h

// Copyright 2012-2023:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Dynamic Compact Control Language Library
// ("DCCL").
//
// DCCL is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// DCCL 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
#ifndef DCCLDYNAMICPROTOBUFMANAGER20110419H
#define DCCLDYNAMICPROTOBUFMANAGER20110419H
 
#include <dlfcn.h>
 
#include <stdexcept>
 
#include <google/protobuf/compiler/importer.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/descriptor_database.h>
#include <google/protobuf/dynamic_message.h>
 
#include <memory>
 
#include "thread_safety.h"
 
namespace dccl
{
class DynamicProtobufManager
{
  public:
    DynamicProtobufManager(const DynamicProtobufManager&) = delete;
    DynamicProtobufManager& operator=(const DynamicProtobufManager&) = delete;
 
    static const google::protobuf::Descriptor*
    find_descriptor(const std::string& protobuf_type_name, bool user_pool_first = false);
 
    template <typename GoogleProtobufMessagePointer>
    static GoogleProtobufMessagePointer new_protobuf_message(const std::string& protobuf_type_name,
                                                             bool user_pool_first = false)
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
 
        const google::protobuf::Descriptor* desc =
            find_descriptor(protobuf_type_name, user_pool_first);
        if (desc)
            return new_protobuf_message<GoogleProtobufMessagePointer>(desc);
        else
            throw(std::runtime_error("Unknown type " + protobuf_type_name +
                                     ", be sure it is loaded at compile-time, via dlopen, or with "
                                     "a call to add_protobuf_file()"));
    }
 
    template <typename GoogleProtobufMessagePointer>
    static GoogleProtobufMessagePointer
    new_protobuf_message(const google::protobuf::Descriptor* desc)
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        return GoogleProtobufMessagePointer(
            get_instance()->msg_factory_->GetPrototype(desc)->New());
    }
 
    static std::shared_ptr<google::protobuf::Message>
    new_protobuf_message(const google::protobuf::Descriptor* desc);
 
    static std::shared_ptr<google::protobuf::Message>
    new_protobuf_message(const std::string& protobuf_type_name);
 
    static void add_database(std::shared_ptr<google::protobuf::DescriptorDatabase> database);
 
    static void enable_compilation()
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        get_instance()->enable_disk_source_database();
    }
 
    static const google::protobuf::FileDescriptor*
    load_from_proto_file(const std::string& protofile_absolute_path);
 
    static void add_include_path(const std::string& path);
 
    static void* load_from_shared_lib(const std::string& shared_lib_path);
 
    static void protobuf_shutdown()
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        get_instance()->shutdown();
    }
 
    static const google::protobuf::FileDescriptor*
    add_protobuf_file(const google::protobuf::FileDescriptorProto& proto);
 
    static void reset()
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        inst_.reset(new DynamicProtobufManager, DynamicProtobufManager::custom_deleter);
    }
 
    static void custom_deleter(DynamicProtobufManager* obj) { delete obj; }
 
#if !(DCCL_THREAD_SUPPORT)
    // no way to make these thread safe without the downstream user locking the mutex
 
    static google::protobuf::DynamicMessageFactory& msg_factory()
    {
        return *get_instance()->msg_factory_;
    }
    static google::protobuf::DescriptorPool& user_descriptor_pool()
    {
        return *get_instance()->user_descriptor_pool_;
    }
    static google::protobuf::SimpleDescriptorDatabase& simple_database()
    {
        return *get_instance()->simple_database_;
    }
#else
    template <typename T = void> static google::protobuf::DynamicMessageFactory& msg_factory()
    {
        static_assert(!std::is_same<T, T>::value,
                      "msg_factory() has been removed for thread-safety "
                      "reasons, use msg_factory_call(...) instead.");
        // to suppress warning, will never actually be called
        return *get_instance()->msg_factory_;
    }
    template <typename T = void> static google::protobuf::DescriptorPool& user_descriptor_pool()
    {
        static_assert(!std::is_same<T, T>::value,
                      "user_descriptor_pool() has been removed for thread-safety reasons, use "
                      "user_descriptor_pool_call(...) instead.");
        // to suppress warning, will never actually be called
        return *get_instance()->user_descriptor_pool_;
    }
    template <typename T = void>
    static google::protobuf::SimpleDescriptorDatabase& simple_database()
    {
        static_assert(!std::is_same<T, T>::value,
                      "simple_database() has been removed for thread-safety reasons, use "
                      "simple_database_call(...) instead.");
        // to suppress warning, will never actually be called
        return *get_instance()->simple_database_;
    }
#endif
 
    template <typename ReturnType, typename... Args1, typename... Args2>
    static ReturnType
    msg_factory_call(ReturnType (google::protobuf::DynamicMessageFactory::*func)(Args1...) const,
                     Args2... args)
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        return ((*get_instance()->msg_factory_).*func)(args...);
    }
 
    template <typename ReturnType, typename... Args1, typename... Args2>
    static ReturnType
    user_descriptor_pool_call(ReturnType (google::protobuf::DescriptorPool::*func)(Args1...) const,
                              Args2... args)
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        return ((*get_instance()->user_descriptor_pool_).*func)(args...);
    }
 
    template <typename ReturnType, typename... Args1, typename... Args2>
    static ReturnType
    simple_database_call(ReturnType (google::protobuf::SimpleDescriptorDatabase::*func)(Args1...)
                             const,
                         Args2... args)
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
        return ((*get_instance()->simple_database_).*func)(args...);
    }
 
  private:
    static std::shared_ptr<DynamicProtobufManager> inst_;
    static DynamicProtobufManager* get_instance()
    {
        DCCL_LOCK_DYNAMIC_PROTOBUF_MANAGER_MUTEX
 
        if (!inst_)
            inst_.reset(new DynamicProtobufManager, DynamicProtobufManager::custom_deleter);
        return inst_.get();
    }
 
    DynamicProtobufManager()
        : generated_database_(new google::protobuf::DescriptorPoolDatabase(
              *google::protobuf::DescriptorPool::generated_pool())),
          simple_database_(new google::protobuf::SimpleDescriptorDatabase),
          msg_factory_(new google::protobuf::DynamicMessageFactory)
    {
        databases_.push_back(simple_database_);
        databases_.push_back(generated_database_);
 
        msg_factory_->SetDelegateToGeneratedFactory(true);
 
        update_databases();
    }
 
    ~DynamicProtobufManager() = default;
 
    void shutdown()
    {
        for (auto& dl_handle : dl_handles_) dlclose(dl_handle);
        google::protobuf::ShutdownProtobufLibrary();
        inst_.reset();
    }
 
    void update_databases()
    {
        std::vector<google::protobuf::DescriptorDatabase*> databases;
 
        for (const auto& database : databases_) databases.push_back(database.get());
 
        merged_database_.reset(new google::protobuf::MergedDescriptorDatabase(databases));
        user_descriptor_pool_.reset(new google::protobuf::DescriptorPool(merged_database_.get()));
    }
 
    void enable_disk_source_database();
 
  private:
    std::vector<std::shared_ptr<google::protobuf::DescriptorDatabase>> databases_;
 
    // always used
    std::shared_ptr<google::protobuf::DescriptorPoolDatabase> generated_database_;
    std::shared_ptr<google::protobuf::SimpleDescriptorDatabase> simple_database_;
    std::shared_ptr<google::protobuf::MergedDescriptorDatabase> merged_database_;
    std::shared_ptr<google::protobuf::DescriptorPool> user_descriptor_pool_;
    std::shared_ptr<google::protobuf::DynamicMessageFactory> msg_factory_;
 
    // sometimes used
    std::shared_ptr<google::protobuf::compiler::DiskSourceTree> disk_source_tree_;
    std::shared_ptr<google::protobuf::compiler::SourceTreeDescriptorDatabase> source_database_;
 
    class DLogMultiFileErrorCollector : public google::protobuf::compiler::MultiFileErrorCollector
    {
 
#if GOOGLE_PROTOBUF_VERSION >= 4022000        
        void RecordError(absl::string_view filename, int line, int column,
                      absl::string_view message) override;
#else
        void AddError(const std::string& filename, int line, int column,
                      const std::string& message) override;
#endif  
    };
 
    std::shared_ptr<DLogMultiFileErrorCollector> error_collector_;
 
    std::vector<void*> dl_handles_;
};
 
} // namespace dccl
 
#endif