decl.hpp

Go to the documentation of this file.

// Copyright (c) 2014-2023, Lawrence Livermore National Security, LLC.
// Produced at the Lawrence Livermore National Laboratory.
// Written by the LBANN Research Team (B. Van Essen, et al.) listed in
// the CONTRIBUTORS file. <lbann-dev@llnl.gov>
//
// LLNL-CODE-697807.
// All rights reserved.
//
// This file is part of LBANN: Livermore Big Artificial Neural Network
// Toolkit. For details, see http://software.llnl.gov/LBANN or
// https://github.com/LLNL/LBANN.
//
// Licensed under the Apache License, Version 2.0 (the "Licensee"); you
// may not use this file except in compliance with the License.  You may
// obtain a copy of the License at:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the license.
#ifndef LBANN_UTILS_PROTOBUF_DECL_HPP_INCLUDED
#define LBANN_UTILS_PROTOBUF_DECL_HPP_INCLUDED

#include "lbann/utils/exception.hpp"

#include <google/protobuf/any.pb.h>
#include <google/protobuf/message.h>
#include <google/protobuf/reflection.h>
#include <google/protobuf/repeated_field.h>

#include <memory>
#include <set>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>

namespace lbann {
namespace protobuf {


using int8 = google::protobuf::int8;
using int16 = google::protobuf::int16;
using int32 = google::protobuf::int32;
using int64 = google::protobuf::int64;

using uint8 = google::protobuf::uint8;
using uint16 = google::protobuf::uint16;
using uint32 = google::protobuf::uint32;
using uint64 = google::protobuf::uint64;



bool has_oneof(google::protobuf::Message const& msg,
               std::string const& oneof_name);

google::protobuf::Message const&
get_oneof_message(google::protobuf::Message const& msg,
                  std::string const& oneof_name);

std::string which_oneof(google::protobuf::Message const& msg,
                        std::string const& oneof_name);

std::string message_type(google::protobuf::Message const& msg);

std::string message_type(google::protobuf::Any const& any);



template <typename T>
auto as_vector(google::protobuf::Message const& msg,
               std::string const& field_name) -> std::vector<T>;

template <typename T>
auto as_vector(google::protobuf::RepeatedField<T> const&) -> std::vector<T>;

template <typename T>
auto as_vector(google::protobuf::RepeatedPtrField<T> const&) -> std::vector<T>;

template <typename OutT, typename InT>
auto to_vector(google::protobuf::RepeatedField<InT> const& rf)
  -> std::vector<OutT>;

template <typename T>
auto as_set(google::protobuf::Message const& msg, std::string const& field_name)
  -> std::set<T>;

template <typename T>
auto as_set(google::protobuf::RepeatedField<T> const&) -> std::set<T>;

auto as_set(google::protobuf::RepeatedPtrField<std::string> const&)
  -> std::set<std::string>;

template <typename OutT, typename InT>
auto to_set(google::protobuf::RepeatedField<InT> const&) -> std::set<OutT>;

template <typename T>
auto as_unordered_set(google::protobuf::Message const& msg,
                      std::string const& field_name) -> std::unordered_set<T>;

template <typename T>
auto as_unordered_set(google::protobuf::RepeatedField<T> const&)
  -> std::unordered_set<T>;

auto as_unordered_set(google::protobuf::RepeatedPtrField<std::string> const&)
  -> std::unordered_set<std::string>;

template <typename OutT, typename InT>
auto to_unordered_set(google::protobuf::RepeatedField<InT> const&)
  -> std::unordered_set<OutT>;



void fill(std::istream& is, google::protobuf::Message& msg);

void fill(std::string const& pbuf_str, google::protobuf::Message& msg);

void load(std::string const& pbuf_filename, google::protobuf::Message& msg);

void serialize(std::ostream& os, google::protobuf::Message const& msg);

std::string serialize(google::protobuf::Message const& msg);

void serialize(std::string const& pbuf_filename,
               google::protobuf::Message const& msg);



template <typename T, typename ContainerT>
void assign_to_repeated(google::protobuf::RepeatedField<T>& field,
                        ContainerT const& values);
template <typename ContainerT>
std::string to_space_sep_string(ContainerT const& values);


namespace text {

void fill(std::istream& is, google::protobuf::Message& msg);

void fill(std::string const& str, google::protobuf::Message& msg);

void load(std::string const& ptext_filename, google::protobuf::Message& msg);

void write(std::ostream& os, google::protobuf::Message const& msg);

std::string write(google::protobuf::Message const& msg);

void write(std::string const& ptext_filename,
           google::protobuf::Message const& msg);
} // namespace text
} // namespace protobuf
} // namespace lbann

#endif // LBANN_UTILS_PROTOBUF_DECL_HPP_INCLUDED