field_codec_typed.h

// Copyright 2011-2019:
//   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>
//   Kyle Guilbert <kguilbert@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 DCCLFIELDCODECTYPED20120312H
#define DCCLFIELDCODECTYPED20120312H
 
#include <type_traits>
 
#include "field_codec.h"
 
namespace dccl
{
 
template <typename WireType, typename FieldType, class Enable = void>
class FieldCodecSelector : public FieldCodecBase
{
  public:
    virtual WireType pre_encode(const FieldType& field_value) = 0;
 
    virtual FieldType post_decode(const WireType& wire_value) = 0;
};
 
template <typename WireType, typename FieldType>
class FieldCodecSelector<WireType, FieldType,
                         std::enable_if_t<std::is_same<WireType, FieldType>::value>>
    : public FieldCodecBase
{
  public:
    virtual WireType pre_encode(const FieldType& field_value) { return field_value; }
    virtual FieldType post_decode(const WireType& wire_value) { return wire_value; }
};
 
template <typename WireType, typename FieldType = WireType>
class TypedFieldCodec : public FieldCodecSelector<WireType, FieldType>
{
  public:
    using wire_type = WireType;
    using field_type = FieldType;
 
  public:
    virtual Bitset encode() = 0;
 
    virtual Bitset encode(const WireType& wire_value) = 0;
 
    virtual WireType decode(Bitset* bits) = 0;
 
    virtual unsigned size() = 0;
 
    virtual unsigned size(const WireType& wire_value) = 0;
 
  private:
    unsigned any_size(const dccl::any& wire_value) override
    {
        try
        {
            return is_empty(wire_value) ? size() : size(dccl::any_cast<WireType>(wire_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("size", typeid(WireType), wire_value.type()));
        }
    }
 
    void any_encode(Bitset* bits, const dccl::any& wire_value) override
    {
        try
        {
            *bits = is_empty(wire_value) ? encode() : encode(dccl::any_cast<WireType>(wire_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("encode", typeid(WireType), wire_value.type()));
        }
    }
 
    void any_decode(Bitset* bits, dccl::any* wire_value) override
    {
        any_decode_specific<WireType>(bits, wire_value);
    }
 
    void any_pre_encode(dccl::any* wire_value, const dccl::any& field_value) override
    {
        try
        {
            if (!is_empty(field_value))
                *wire_value = this->pre_encode(dccl::any_cast<FieldType>(field_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("pre_encode", typeid(FieldType), field_value.type()));
        }
        catch (NullValueException&)
        {
            *wire_value = dccl::any();
        }
    }
 
    void any_post_decode(const dccl::any& wire_value, dccl::any* field_value) override
    {
        any_post_decode_specific<WireType>(wire_value, field_value);
    }
 
    // we don't currently support type conversion (post_decode / pre_encode) of Message types
    template <typename T>
    typename std::enable_if_t<std::is_base_of<google::protobuf::Message, T>::value, void>
    any_post_decode_specific(const dccl::any& wire_value, dccl::any* field_value)
    {
        *field_value = wire_value;
    }
 
    template <typename T>
    typename std::enable_if_t<!std::is_base_of<google::protobuf::Message, T>::value, void>
    any_post_decode_specific(const dccl::any& wire_value, dccl::any* field_value)
    {
        try
        {
            if (!is_empty(wire_value))
                *field_value = this->post_decode(dccl::any_cast<WireType>(wire_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("post_decode", typeid(WireType), wire_value.type()));
        }
        catch (NullValueException&)
        {
            *field_value = dccl::any();
        }
    }
 
    template <typename T>
    typename std::enable_if_t<std::is_base_of<google::protobuf::Message, T>::value, void>
    any_decode_specific(Bitset* bits, dccl::any* wire_value)
    {
        try
        {
            auto* msg = dccl::any_cast<google::protobuf::Message*>(*wire_value);
            msg->CopyFrom(decode(bits));
        }
        catch (NullValueException&)
        {
            if (FieldCodecBase::this_field())
                *wire_value = dccl::any();
        }
    }
 
    template <typename T>
    typename std::enable_if_t<!std::is_base_of<google::protobuf::Message, T>::value, void>
    any_decode_specific(Bitset* bits, dccl::any* wire_value)
    {
        try
        {
            *wire_value = decode(bits);
        }
        catch (NullValueException&)
        {
            *wire_value = dccl::any();
        }
    }
};
 
template <typename WireType, typename FieldType = WireType>
class RepeatedTypedFieldCodec : public TypedFieldCodec<WireType, FieldType>
{
  public:
    using wire_type = WireType;
    using field_type = FieldType;
 
  public:
    virtual Bitset encode_repeated(const std::vector<WireType>& wire_value) = 0;
 
    virtual std::vector<WireType> decode_repeated(Bitset* bits) = 0;
 
    virtual unsigned size_repeated(const std::vector<WireType>& wire_values) = 0;
 
    unsigned max_size_repeated() override = 0;
 
    unsigned min_size_repeated() override = 0;
 
    Bitset encode() override { return encode_repeated(std::vector<WireType>()); }
 
    Bitset encode(const WireType& wire_value) override
    {
        return encode_repeated(std::vector<WireType>(1, wire_value));
    }
 
    WireType decode(dccl::Bitset* bits) override
    {
        std::vector<WireType> return_vec = decode_repeated(bits);
        if (is_empty(return_vec))
            throw dccl::NullValueException();
        else
            return return_vec.at(0);
    }
 
    unsigned size() override { return size_repeated(std::vector<WireType>()); }
 
    unsigned size(const WireType& wire_value) override
    {
        return size_repeated(std::vector<WireType>(1, wire_value));
    }
 
    unsigned max_size() override { return max_size_repeated(); }
 
    unsigned min_size() override { return min_size_repeated(); }
 
  private:
    void any_encode_repeated(Bitset* bits, const std::vector<dccl::any>& wire_values) override
    {
        try
        {
            std::vector<WireType> in;
            for (const auto& wire_value : wire_values)
            { in.push_back(dccl::any_cast<WireType>(wire_value)); } *bits = encode_repeated(in);
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("encode_repeated", typeid(WireType), wire_values.at(0).type()));
        }
    }
 
    void any_decode_repeated(Bitset* repeated_bits, std::vector<dccl::any>* field_values) override
    {
        any_decode_repeated_specific<WireType>(repeated_bits, field_values);
    }
 
    template <typename T>
    typename std::enable_if_t<std::is_base_of<google::protobuf::Message, T>::value, void>
    any_decode_repeated_specific(Bitset* repeated_bits, std::vector<dccl::any>* wire_values)
    {
        std::vector<WireType> decoded_msgs = decode_repeated(repeated_bits);
        wire_values->resize(decoded_msgs.size(), WireType());
 
        for (int i = 0, n = decoded_msgs.size(); i < n; ++i)
        {
            auto* msg = dccl::any_cast<google::protobuf::Message*>(wire_values->at(i));
            msg->CopyFrom(decoded_msgs[i]);
        }
    }
 
    template <typename T>
    typename std::enable_if_t<!std::is_base_of<google::protobuf::Message, T>::value, void>
    any_decode_repeated_specific(Bitset* repeated_bits, std::vector<dccl::any>* wire_values)
    {
        std::vector<WireType> decoded = decode_repeated(repeated_bits);
        wire_values->resize(decoded.size(), WireType());
 
        for (int i = 0, n = decoded.size(); i < n; ++i) wire_values->at(i) = decoded[i];
    }
 
    void any_pre_encode(dccl::any* wire_value, const dccl::any& field_value) override
    {
        try
        {
            if (!is_empty(field_value))
                *wire_value = this->pre_encode(dccl::any_cast<FieldType>(field_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("pre_encode", typeid(FieldType), field_value.type()));
        }
        catch (NullValueException&)
        {
            *wire_value = dccl::any();
        }
    }
 
    void any_post_decode(const dccl::any& wire_value, dccl::any* field_value) override
    {
        try
        {
            if (!is_empty(wire_value))
                *field_value = this->post_decode(dccl::any_cast<WireType>(wire_value));
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("post_decode", typeid(WireType), wire_value.type()));
        }
        catch (NullValueException&)
        {
            *field_value = dccl::any();
        }
    }
 
    //          void any_pre_encode_repeated(std::vector<dccl::any>* wire_values,
    //                                       const std::vector<dccl::any>& field_values);
 
    //          void any_post_decode_repeated(const std::vector<dccl::any>& wire_values,
    //                                        std::vector<dccl::any>* field_values);
 
    unsigned any_size_repeated(const std::vector<dccl::any>& wire_values) override
    {
        try
        {
            std::vector<WireType> in;
            for (const auto& wire_value : wire_values)
            { in.push_back(dccl::any_cast<WireType>(wire_value)); } return size_repeated(in);
        }
        catch (dccl::bad_any_cast&)
        {
            throw(type_error("size_repeated", typeid(WireType), wire_values.at(0).type()));
        }
    }
};
 
} // namespace dccl
 
#endif