field_codec.h

// Copyright 2009-2017 Toby Schneider (http://gobysoft.org/index.wt/people/toby)
//                     GobySoft, LLC (for 2013-)
//                     Massachusetts Institute of Technology (for 2007-2014)
//                     Community contributors (see AUTHORS file)
//
//
// 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 <boost/any.hpp>
#include <boost/lexical_cast.hpp>
 
#include <google/protobuf/message.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/descriptor.h>
 
#include "common.h"
#include "exception.h"
#include "dccl/option_extensions.pb.h"
#include "internal/type_helper.h"
#include "internal/field_codec_message_stack.h"
#include "dccl/binary.h"
 
namespace dccl
{
    class Codec;
 
    class FieldCodecBase
    {
      public:
 
            
        FieldCodecBase();
        virtual ~FieldCodecBase() { }
            
 
        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 
        { return !internal::MessageStack::field_.empty() ? internal::MessageStack::field_.back() : 0; }
            
        static const google::protobuf::Descriptor* this_descriptor()
        { return !internal::MessageStack::desc_.empty() ? internal::MessageStack::desc_.back() : 0; }
 
        // currently encoded or (partially) decoded root message
        static const google::protobuf::Message* root_message()
        { return root_message_; }
 
        static bool has_codec_group()
        {
            if(root_descriptor_)
            {
                return root_descriptor_->options().GetExtension(dccl::msg).has_codec_group() ||
                    root_descriptor_->options().GetExtension(dccl::msg).has_codec_version();
            }
            else
                return false;
        }
 
        static std::string codec_group(const google::protobuf::Descriptor* desc);
 
        static std::string codec_group()
        { return codec_group(root_descriptor_); }
 
        static int codec_version()
        { return root_descriptor_->options().GetExtension(dccl::msg).codec_version(); }
            
        static MessagePart part() { return part_; }
 
        static bool strict() { return 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 field_pre_encode(boost::any* wire_value, const boost::any& field_value)
        { any_pre_encode(wire_value, field_value); }
 
        void field_pre_encode_repeated(std::vector<boost::any>* wire_values,
                                       const std::vector<boost::any>& field_values)
        { any_pre_encode_repeated(wire_values, field_values); }
            
        // traverse const
 
        void field_encode(Bitset* bits,
                          const boost::any& field_value,
                          const google::protobuf::FieldDescriptor* field);
 
        void field_encode_repeated(Bitset* bits,
                                   const std::vector<boost::any>& field_values,
                                   const google::protobuf::FieldDescriptor* field);
 
        void field_size(unsigned* bit_size, const boost::any& field_value,
                        const google::protobuf::FieldDescriptor* field);
            
        void field_size_repeated(unsigned* bit_size, const std::vector<boost::any>& field_values,
                                 const google::protobuf::FieldDescriptor* field);
 
        // traverse mutable
        void field_decode(Bitset* bits,
                          boost::any* field_value,
                          const google::protobuf::FieldDescriptor* field);            
 
        void field_decode_repeated(Bitset* bits,
                                   std::vector<boost::any>* field_values,
                                   const google::protobuf::FieldDescriptor* field);
 
        void field_post_decode(const boost::any& wire_value, boost::any* field_value)
        { any_post_decode(wire_value, field_value); }
 
        void field_post_decode_repeated(const std::vector<boost::any>& wire_values,
                                        std::vector<boost::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);
            
      protected:
 
        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));
                else
                    throw(Exception("Message " + this_descriptor()->name() + " failed validation: " + description));
            }
                
        }
 
        bool use_required()
        {
            if(force_required_)
                return true;
 
            const google::protobuf::FieldDescriptor* field = this_field();
            if(!field)
                return true;
            else if(codec_version() > 2) // use required for both repeated and required fields
                return field->is_required() || field->is_repeated();
            else // use required only for required fields
                return field->is_required();
        }
        
        
        // 
        // VIRTUAL
        //
 
        // contain boost::any
        virtual void any_encode(Bitset* bits, const boost::any& wire_value) = 0;
 
        virtual void any_decode(Bitset* bits, boost::any* wire_value) = 0;
 
        virtual void any_pre_encode(boost::any* wire_value,
                                    const boost::any& field_value) 
        { *wire_value = field_value; }
 
        virtual void any_post_decode(const boost::any& wire_value,
                                     boost::any* field_value)
        { *field_value = wire_value; }
 
        virtual unsigned any_size(const boost::any& wire_value) = 0;
 
        // no boost::any
        virtual void validate() { }
 
        virtual std::string info();
            
        virtual unsigned max_size() = 0;
 
        virtual unsigned min_size() = 0;
 
        virtual void any_encode_repeated(Bitset* bits, const std::vector<boost::any>& wire_values);
        virtual void any_decode_repeated(Bitset* repeated_bits, std::vector<boost::any>* field_values);
 
        virtual void any_pre_encode_repeated(std::vector<boost::any>* wire_values,
                                             const std::vector<boost::any>& field_values);
            
        virtual void any_post_decode_repeated(const std::vector<boost::any>& wire_values,
                                              std::vector<boost::any>* field_values);
            
        virtual unsigned any_size_repeated(const std::vector<boost::any>& wire_values);
        virtual unsigned max_size_repeated();
        virtual unsigned min_size_repeated();
            
        friend class FieldCodecManager;
      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 max_repeat)
        { return dccl::ceil_log2(max_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(MessagePart part,
                     const google::protobuf::Descriptor* root_descriptor,
                     bool strict = false)
                {
                    FieldCodecBase::part_ = part;
                    FieldCodecBase::strict_ = strict;
                    FieldCodecBase::root_message_ = 0;
                    FieldCodecBase::root_descriptor_ = root_descriptor;
                }
 
            BaseRAII(MessagePart part,            
                     const google::protobuf::Message* root_message,
                     bool strict = false)                
                {
                    FieldCodecBase::part_ = part;
                    FieldCodecBase::strict_ = strict;
                    FieldCodecBase::root_message_ = root_message;
                    FieldCodecBase::root_descriptor_ = root_message->GetDescriptor();                    
                }
            ~BaseRAII()
                {
                    FieldCodecBase::part_ = dccl::UNKNOWN;
                    FieldCodecBase::strict_ = false;
                    FieldCodecBase::root_message_ = 0;
                    FieldCodecBase::root_descriptor_ = 0;
                }
        };
        
        
        static MessagePart part_;
        static bool strict_;
        static const google::protobuf::Message* root_message_;
        static const google::protobuf::Descriptor* root_descriptor_;
        
        std::string name_;
        google::protobuf::FieldDescriptor::Type field_type_;
        google::protobuf::FieldDescriptor::CppType wire_type_;
 
        bool force_required_;
 
    };
 
    inline std::ostream& operator<<(std::ostream& os, const FieldCodecBase& field_codec )
    {
        using google::protobuf::FieldDescriptor;
        using internal::TypeHelper;
        return os << "[FieldCodec '" << field_codec.name() << "']: field type: "
                  << TypeHelper::find(field_codec.field_type())->as_str()
                  << " (" << TypeHelper::find(FieldDescriptor::TypeToCppType(field_codec.field_type()))->as_str()
                  << ") | wire type: " << TypeHelper::find(field_codec.wire_type())->as_str();
    }
 
    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);
    }
 
        
}
 
 
#endif