dccl_constants.h

Go to the documentation of this file.

// Copyright 2011-2025:
//   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 Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them 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.
//
// The Goby Libraries are distributed in the hope that they 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 Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_MOOS_TRANSITIONAL_DCCL_CONSTANTS_H
#define GOBY_MOOS_TRANSITIONAL_DCCL_CONSTANTS_H
 
#include <bitset>
#include <cmath>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
 
//#include <boost/dynamic_bitset.hpp>
 
#include "goby/acomms/acomms_constants.h"
#include "goby/acomms/dccl.h"
 
namespace goby
{
namespace moos
{
namespace transitional
{
enum DCCLType
{
    dccl_static,
    dccl_bool,
    dccl_int,
    dccl_float,
    dccl_enum,
    dccl_string,
    dccl_hex
};
enum DCCLCppType
{
    cpp_notype, 
    cpp_bool,   
    cpp_string, 
    cpp_long,   
    cpp_double  
};
 
// 2^3 = 8
enum
{
    POWER2_BITS_IN_BYTE = 3
};
inline unsigned bits2bytes(unsigned bits) { return bits >> POWER2_BITS_IN_BYTE; }
inline unsigned bytes2bits(unsigned bytes) { return bytes << POWER2_BITS_IN_BYTE; }
 
// 2^1 = 2
enum
{
    POWER2_NIBS_IN_BYTE = 1
};
inline unsigned bytes2nibs(unsigned bytes) { return bytes << POWER2_NIBS_IN_BYTE; }
inline unsigned nibs2bytes(unsigned nibs) { return nibs >> POWER2_NIBS_IN_BYTE; }
 
inline std::string type_to_string(DCCLType type)
{
    switch (type)
    {
        case dccl_int: return "int";
        case dccl_hex: return "hex";
        case dccl_bool: return "bool";
        case dccl_string: return "string";
        case dccl_float: return "float";
        case dccl_static: return "static";
        case dccl_enum: return "enum";
    }
    return "notype";
}
 
inline std::string type_to_protobuf_type(DCCLType type)
{
    switch (type)
    {
        case dccl_int: return "int32";
        case dccl_hex: return "bytes";
        case dccl_bool: return "bool";
        case dccl_string: return "string";
        case dccl_float: return "double";
        case dccl_static: return "string";
        default:
            throw(goby::acomms::DCCLException(
                "cannot directly map DCCLv1 XML type to Protobuf Type"));
    }
    return "notype";
}
 
inline std::string type_to_string(DCCLCppType type)
{
    switch (type)
    {
        case cpp_long: return "long";
        case cpp_double: return "double";
        case cpp_string: return "string";
        case cpp_bool: return "bool";
        case cpp_notype: return "no_type";
    }
    return "notype";
}
 
const unsigned DCCL_NUM_HEADER_BYTES = 6;
 
const unsigned DCCL_NUM_HEADER_PARTS = 8;
 
enum DCCLHeaderPart
{
    HEAD_CCL_ID = 0,
    HEAD_DCCL_ID = 1,
    HEAD_TIME = 2,
    HEAD_SRC_ID = 3,
    HEAD_DEST_ID = 4,
    HEAD_MULTIMESSAGE_FLAG = 5,
    HEAD_BROADCAST_FLAG = 6,
    HEAD_UNUSED = 7
};
 
const std::string DCCL_HEADER_NAMES[] = {
    "_ccl_id",         "_id",     "_time", "_src_id", "_dest_id", "_multimessage_flag",
    "_broadcast_flag", "_unused",
};
inline std::string to_str(DCCLHeaderPart p) { return DCCL_HEADER_NAMES[p]; }
 
enum DCCLHeaderBits
{
    HEAD_CCL_ID_SIZE = 8,
    HEAD_DCCL_ID_SIZE = 9,
    HEAD_TIME_SIZE = 17,
    HEAD_SRC_ID_SIZE = 5,
    HEAD_DEST_ID_SIZE = 5,
    HEAD_FLAG_SIZE = 1,
    HEAD_UNUSED_SIZE = 2
};
 
 
 
inline bool char_array2hex_string(const unsigned char* c, std::string& s, const unsigned int n)
{
    std::stringstream ss;
    for (unsigned int i = 0; i < n; i++)
        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(c[i]);
 
    s = ss.str();
    return true;
}
 
inline bool hex_string2char_array(unsigned char* c, const std::string& s, const unsigned int n)
{
    for (unsigned int i = 0; i < n; i++)
    {
        std::stringstream ss;
        unsigned int in;
        ss << s.substr(2 * i, 2);
        ss >> std::hex >> in;
        c[i] = static_cast<unsigned char>(in);
    }
    return true;
}
 
inline std::string long2binary_string(unsigned long l, unsigned short bits)
{
    std::string s(bits + 1, '\0');
    for (unsigned int i = 0; i < bits; i++)
    {
        s[bits - i - 1] = (l & 1) ? '1' : '0';
        l >>= 1;
    }
    s[bits] = '\0';
    return s;
}
 
inline std::string binary_string2hex_string(const std::string& bs)
{
    std::string hs;
    auto bytes = (unsigned int)(std::ceil(bs.length() / 8.0));
    std::vector<unsigned char> c(bytes, 0);
 
    for (size_t i = 0; i < bytes; ++i)
    {
        std::bitset<8> b(bs.substr(i * 8, 8));
        c[i] = (char)b.to_ulong();
    }
 
    char_array2hex_string(c.data(), hs, bytes);
 
    return hs;
}
 
inline std::string hex_string2binary_string(const std::string& bs)
{
    int bytes = bs.length() / 2;
    std::vector<unsigned char> c(bytes, 0);
 
    hex_string2char_array(c.data(), bs, bytes);
 
    std::string hs;
 
    for (size_t i = 0; i < (size_t)bytes; i++) hs += long2binary_string((unsigned long)c[i], 8);
 
    return hs;
}
 
template <typename T> bool hex_string2number(const std::string& s, T& t)
{
    std::stringstream ss;
    ss << s;
    ss >> std::hex >> t;
    return !ss.fail();
}
 
template <typename T> bool number2hex_string(std::string& s, const T& t, unsigned int width = 2)
{
    std::stringstream ss;
    ss << std::hex << std::setw(width) << std::setfill('0') << static_cast<unsigned int>(t);
    s = ss.str();
    return !ss.fail();
}
 
template <typename T> std::string number2hex_string(const T& t, unsigned int width = 2)
{
    std::string s;
    number2hex_string(s, t, width);
    return s;
}
 
} // namespace transitional
} // namespace moos
} // namespace goby
#endif