field_codec.h

// Copyright 2011-2023:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//   Chris Murphy <cmurphy@aphysci.com>
//
//
// 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 DCCLFIELDCODEC20110322H
#define DCCLFIELDCODEC20110322H
 
#include <map>
#include <string>
 
#include <google/protobuf/descriptor.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/message.h>
 
#include "any.h"
#include "binary.h"
#include "common.h"
#include "dynamic_conditions.h"
#include "exception.h"
#include "internal/field_codec_message_stack.h"
#include "internal/type_helper.h"
#include "oneof.h"
#include "option_extensions.pb.h"
 
namespace dccl
{
class Codec;
namespace internal
{
class MessageStack;
}
 
class FieldCodecBase
{
  public:
 
 
    FieldCodecBase();
    virtual ~FieldCodecBase() = default;
 
 
    std::string name() const { return name_; }
    google::protobuf::FieldDescriptor::Type field_type() const { return field_type_; }
    google::protobuf::FieldDescriptor::CppType wire_type() const { return wire_type_; }
 
    const google::protobuf::FieldDescriptor* this_field() const;
 
    const google::protobuf::Descriptor* this_descriptor() const;
 
    const google::protobuf::Message* this_message();
 
    // currently encoded or (partially) decoded root message
    const google::protobuf::Message* root_message();
 
    const google::protobuf::Descriptor* root_descriptor() const;
 
    internal::MessageStackData& message_data();
 
    const internal::MessageStackData& message_data() const;
 
    bool has_codec_group();
 
    static std::string codec_group(const google::protobuf::Descriptor* desc);
 
    std::string codec_group();
 
    int codec_version();
 
    MessagePart part();
 
    bool strict();
 
    void set_force_use_required(bool force_required = true) { force_required_ = force_required; }
 
 
 
 
    void base_encode(Bitset* bits, const google::protobuf::Message& msg, MessagePart part,
                     bool strict);
 
    void base_size(unsigned* bit_size, const google::protobuf::Message& msg, MessagePart part);
 
    void base_decode(Bitset* bits, google::protobuf::Message* msg, MessagePart part);
 
    void base_max_size(unsigned* bit_size, const google::protobuf::Descriptor* desc,
                       MessagePart part);
 
    void base_min_size(unsigned* bit_size, const google::protobuf::Descriptor* desc,
                       MessagePart part);
 
    void base_validate(const google::protobuf::Descriptor* desc, MessagePart part);
 
    void base_info(std::ostream* os, const google::protobuf::Descriptor* desc, MessagePart part);
 
    void base_hash(std::size_t* hash, const google::protobuf::Descriptor* desc, MessagePart part);
 
    //
 
 
    void field_pre_encode(dccl::any* wire_value, const dccl::any& field_value)
    {
        any_pre_encode(wire_value, field_value);
    }
 
    void field_pre_encode_repeated(std::vector<dccl::any>* wire_values,
                                   const std::vector<dccl::any>& field_values)
    {
        any_pre_encode_repeated(wire_values, field_values);
    }
 
    // traverse const
 
    void field_encode(Bitset* bits, const dccl::any& field_value,
                      const google::protobuf::FieldDescriptor* field);
 
    void field_encode_repeated(Bitset* bits, const std::vector<dccl::any>& field_values,
                               const google::protobuf::FieldDescriptor* field);
 
    void field_size(unsigned* bit_size, const dccl::any& field_value,
                    const google::protobuf::FieldDescriptor* field);
 
    void field_size_repeated(unsigned* bit_size, const std::vector<dccl::any>& field_values,
                             const google::protobuf::FieldDescriptor* field);
 
    // traverse mutable
    void field_decode(Bitset* bits, dccl::any* field_value,
                      const google::protobuf::FieldDescriptor* field);
 
    void field_decode_repeated(Bitset* bits, std::vector<dccl::any>* field_values,
                               const google::protobuf::FieldDescriptor* field);
 
    void field_post_decode(const dccl::any& wire_value, dccl::any* field_value)
    {
        any_post_decode(wire_value, field_value);
    }
 
    void field_post_decode_repeated(const std::vector<dccl::any>& wire_values,
                                    std::vector<dccl::any>* field_values)
    {
        any_post_decode_repeated(wire_values, field_values);
    }
 
    // traverse schema (Descriptor)
 
    void field_max_size(unsigned* bit_size, const google::protobuf::FieldDescriptor* field);
    void field_min_size(unsigned* bit_size, const google::protobuf::FieldDescriptor* field);
 
    void field_validate(bool* b, const google::protobuf::FieldDescriptor* field);
 
    void field_info(std::ostream* os, const google::protobuf::FieldDescriptor* field);
 
    void field_hash(std::size_t* hash, const google::protobuf::FieldDescriptor* field);
 
    dccl::DCCLFieldOptions dccl_field_options() const
    {
        if (this_field())
            return this_field()->options().GetExtension(dccl::field);
        else
            throw(Exception(
                "Cannot call dccl_field on base message (has no *field* option extension"));
    }
 
    void require(bool b, const std::string& description)
    {
        if (!b)
        {
            if (this_field())
                throw(Exception("Field " + this_field()->name() +
                                    " failed validation: " + description,
                                this->this_descriptor()));
            else
                throw(Exception("Message " + this_descriptor()->name() +
                                    " failed validation: " + description,
                                this->this_descriptor()));
        }
    }
 
    DynamicConditions& dynamic_conditions(const google::protobuf::FieldDescriptor* field);
 
    FieldCodecManagerLocal& manager()
    {
        if (manager_)
            return *manager_;
        else
            throw(Exception("FieldCodecManagerLocal is not set"), this->this_descriptor());
    }
 
    const FieldCodecManagerLocal& manager() const
    {
        if (manager_)
            return *manager_;
        else
            throw(Exception("FieldCodecManagerLocal is not set"), this->this_descriptor());
    }
 
    virtual void set_manager(FieldCodecManagerLocal* manager) { manager_ = manager; }
 
  protected:
    bool use_required()
    {
        if (force_required_)
            return true;
 
        const google::protobuf::FieldDescriptor* field = this_field();
        DynamicConditions& dc = dynamic_conditions(field);
        // expensive, so don't do this unless we're going to use it
        if (dc.has_required_if())
            dc.regenerate(this_message(), root_message());
 
        if (!field)
            return true;
        else if (codec_version() > 3) // use required for repeated, required and oneof fields
            return field->is_required() || field->is_repeated() || is_part_of_oneof(field) ||
                   (dc.has_required_if() && dc.required());
        else if (codec_version() > 2) // use required for both repeated and required fields
            return field->is_required() || field->is_repeated() ||
                   (dc.has_required_if() && dc.required());
        else // use required only for required fields
            return field->is_required();
    }
 
    //
    // VIRTUAL
    //
 
    // contain dccl::any
    virtual void any_encode(Bitset* bits, const dccl::any& wire_value) = 0;
 
    virtual void any_decode(Bitset* bits, dccl::any* wire_value) = 0;
 
    virtual void any_pre_encode(dccl::any* wire_value, const dccl::any& field_value)
    {
        *wire_value = field_value;
    }
 
    virtual void any_post_decode(const dccl::any& wire_value, dccl::any* field_value)
    {
        *field_value = wire_value;
    }
 
    virtual unsigned any_size(const dccl::any& wire_value) = 0;
 
    // no dccl::any
    virtual void validate() {}
 
    virtual std::string info();
 
    virtual std::size_t hash() { return 0; }
 
    virtual unsigned max_size() = 0;
 
    virtual unsigned min_size() = 0;
 
    virtual void any_encode_repeated(Bitset* bits, const std::vector<dccl::any>& wire_values);
    virtual void any_decode_repeated(Bitset* repeated_bits, std::vector<dccl::any>* field_values);
 
    virtual void any_pre_encode_repeated(std::vector<dccl::any>* wire_values,
                                         const std::vector<dccl::any>& field_values);
 
    virtual void any_post_decode_repeated(const std::vector<dccl::any>& wire_values,
                                          std::vector<dccl::any>* field_values);
 
    virtual unsigned any_size_repeated(const std::vector<dccl::any>& wire_values);
    virtual unsigned max_size_repeated();
    virtual unsigned min_size_repeated();
    void check_repeat_settings() const;
 
    friend class FieldCodecManagerLocal;
 
  private:
    // codec information
    void set_name(const std::string& name) { name_ = name; }
    void set_field_type(google::protobuf::FieldDescriptor::Type type) { field_type_ = type; }
    void set_wire_type(google::protobuf::FieldDescriptor::CppType type) { wire_type_ = type; }
 
    bool variable_size()
    {
        if (this_field() && this_field()->is_repeated())
            return max_size_repeated() != min_size_repeated();
        else
            return max_size() != min_size();
    }
 
    int repeated_vector_field_size(int min_repeat, int max_repeat)
    {
        return dccl::ceil_log2(max_repeat - min_repeat + 1);
    }
 
    void disp_size(const google::protobuf::FieldDescriptor* field, const Bitset& new_bits,
                   int depth, int vector_size = -1);
 
  private:
    // sets global statics relating the current message begin processed
    // and unsets them on destruction
    struct BaseRAII
    {
        BaseRAII(FieldCodecBase* field_codec, MessagePart part,
                 const google::protobuf::Descriptor* root_descriptor, bool strict = false);
 
        BaseRAII(FieldCodecBase* field_codec, MessagePart part,
                 const google::protobuf::Message* root_message, bool strict = false);
        ~BaseRAII();
 
      private:
        FieldCodecBase* field_codec_;
    };
    friend struct BaseRAII;
 
    std::string name_;
    google::protobuf::FieldDescriptor::Type field_type_;
    google::protobuf::FieldDescriptor::CppType wire_type_;
 
    bool force_required_{false};
 
    FieldCodecManagerLocal* manager_{nullptr};
};
 
std::ostream& operator<<(std::ostream& os, const FieldCodecBase& field_codec);
 
inline Exception type_error(const std::string& action, const std::type_info& expected,
                            const std::type_info& got)
{
    std::string e = "error " + action + ", expected: ";
    e += expected.name();
    e += ", got ";
    e += got.name();
    return Exception(e);
}
 
} // namespace dccl
 
#endif