ccl_compatibility.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 DCCLCCLCOMPATIBILITY20120426H
#define DCCLCCLCOMPATIBILITY20120426H
 
#include "../codecs2/field_codec_default.h"
#include "../field_codec_id.h"
#include "dccl/ccl/protobuf/ccl.pb.h"
#include "dccl/ccl/protobuf/ccl_extensions.pb.h"
 
extern "C"
{
    void dccl3_load(dccl::Codec* dccl);
}
 
namespace dccl
{
namespace legacyccl
{
const unsigned char DCCL_CCL_HEADER = 32;
 
class IdentifierCodec : public DefaultIdentifierCodec
{
  private:
    dccl::Bitset encode() override { return encode(0); }
 
    dccl::Bitset encode(const dccl::uint32& wire_value) override
    {
        if ((wire_value & 0xFFFF0000) == CCL_DCCL_ID_PREFIX)
        {
            // CCL message
            return dccl::Bitset(dccl::BITS_IN_BYTE, wire_value & 0x0000FFFF);
        }
        else
        {
            // DCCL message
            return dccl::DefaultIdentifierCodec::encode(wire_value)
                .prepend(dccl::Bitset(dccl::BITS_IN_BYTE, DCCL_CCL_HEADER));
        }
    }
 
    dccl::uint32 decode(dccl::Bitset* bits) override
    {
        unsigned ccl_id = bits->to_ulong();
 
        if (ccl_id == DCCL_CCL_HEADER)
        {
            // DCCL message
            bits->get_more_bits(dccl::DefaultIdentifierCodec::min_size());
            (*bits) >>= dccl::BITS_IN_BYTE;
            bits->resize(dccl::DefaultIdentifierCodec::min_size());
            return dccl::DefaultIdentifierCodec::decode(bits);
        }
        else
        {
            // CCL message
            return CCL_DCCL_ID_PREFIX + ccl_id;
        }
    }
 
    unsigned size() override { return size(0); }
 
    unsigned size(const dccl::uint32& field_value) override
    {
        if ((field_value & 0xFFFF0000) == CCL_DCCL_ID_PREFIX)
        {
            // CCL message
            return dccl::BITS_IN_BYTE;
        }
        else
        {
            return dccl::BITS_IN_BYTE + dccl::DefaultIdentifierCodec::size(field_value);
        }
    }
 
    unsigned max_size() override
    {
        return dccl::BITS_IN_BYTE + dccl::DefaultIdentifierCodec::max_size();
    }
 
    unsigned min_size() override { return dccl::BITS_IN_BYTE; }
 
    // prefixes (dccl.msg).id to indicate that this DCCL
    // message is an encoding of a legacy CCL message
    enum
    {
        CCL_DCCL_ID_PREFIX = 0x0CC10000
    };
};
 
class LatLonCompressedCodec : public dccl::TypedFixedFieldCodec<double>
{
  private:
    dccl::Bitset encode() override;
    dccl::Bitset encode(const double& wire_value) override;
    double decode(dccl::Bitset* bits) override;
    unsigned size() override;
    enum
    {
        LATLON_COMPRESSED_BYTE_SIZE = 3
    };
};
 
class FixAgeCodec : public dccl::v2::DefaultNumericFieldCodec<dccl::uint32>
{
  private:
    dccl::Bitset encode() override { return encode((dccl::uint32)max()); }
 
    dccl::Bitset encode(const dccl::uint32& wire_value) override
    {
        return dccl::v2::DefaultNumericFieldCodec<dccl::uint32>::encode(
            (dccl::uint32)std::min<unsigned char>((dccl::uint32)max(), wire_value / SCALE_FACTOR));
    }
 
    dccl::uint32 decode(dccl::Bitset* bits) override
    {
        return SCALE_FACTOR * dccl::v2::DefaultNumericFieldCodec<dccl::uint32>::decode(bits);
    }
 
    double max() override { return (1 << dccl::BITS_IN_BYTE) - 1; }
    double min() override { return 0; }
    void validate() override {}
 
    enum
    {
        SCALE_FACTOR = 4
    };
};
 
class TimeDateCodec : public dccl::TypedFixedFieldCodec<dccl::uint64>
{
  public:
    static dccl::uint64 to_uint64_time(const std::time_t& time_date);
 
  private:
    dccl::Bitset encode() override;
    dccl::Bitset encode(const dccl::uint64& wire_value) override;
    dccl::uint64 decode(dccl::Bitset* bits) override;
    unsigned size() override;
 
    enum
    {
        MICROSECONDS_IN_SECOND = 1000000
    };
    enum
    {
        TIME_DATE_COMPRESSED_BYTE_SIZE = 3
    };
};
 
class HeadingCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
class HiResAltitudeCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return HI_RES_ALTITUDE_COMPRESSED_BYTE_SIZE * dccl::BITS_IN_BYTE; }
    enum
    {
        HI_RES_ALTITUDE_COMPRESSED_BYTE_SIZE = 2
    };
};
 
class DepthCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override
    {
        return FieldCodecBase::dccl_field_options().GetExtension(ccl).bit_size();
    }
 
    void validate() override
    {
        FieldCodecBase::require(
            FieldCodecBase::dccl_field_options().GetExtension(ccl).has_bit_size(),
            "missing (dccl.field).ccl.bit_size");
    }
};
 
class VelocityCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
class SpeedCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
 
    void validate() override
    {
        FieldCodecBase::require(
            FieldCodecBase::dccl_field_options().GetExtension(ccl).has_thrust_mode_tag(),
            "missing (dccl.field).ccl.thrust_mode_tag");
    }
};
 
class WattsCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
class GFIPitchOilCodec : public dccl::TypedFixedFieldCodec<protobuf::CCLMDATState::GFIPitchOil>
{
  private:
    dccl::Bitset encode() override { return encode(protobuf::CCLMDATState::GFIPitchOil()); }
    dccl::Bitset encode(const protobuf::CCLMDATState::GFIPitchOil& wire_value) override;
    protobuf::CCLMDATState::GFIPitchOil decode(dccl::Bitset* bits) override;
    unsigned size() override { return GFI_PITCH_OIL_COMPRESSED_BYTE_SIZE * dccl::BITS_IN_BYTE; }
    enum
    {
        GFI_PITCH_OIL_COMPRESSED_BYTE_SIZE = 2
    };
};
 
class SalinityCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
class TemperatureCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
class SoundSpeedCodec : public dccl::TypedFixedFieldCodec<float>
{
  private:
    dccl::Bitset encode() override { return encode(0); }
    dccl::Bitset encode(const float& wire_value) override;
    float decode(dccl::Bitset* bits) override;
    unsigned size() override { return dccl::BITS_IN_BYTE; }
};
 
} // namespace legacyccl
} // namespace dccl
 
#endif