byte_sequence.h

Go to the documentation of this file.

#ifndef __FIPAACL_MESSAGEPARSER_BYTESEQUENCE_H_
#define __FIPAACL_MESSAGEPARSER_BYTESEQUENCE_H_

#include <stdio.h>
#include <string>
#include <vector>

#include <boost/cstdint.hpp>

namespace fipa { namespace acl {

typedef boost::variant<boost::uint_least8_t,boost::uint_least16_t, boost::uint_least32_t> LengthValue;

typedef boost::variant<std::string, std::vector<unsigned char> > ByteString;

class ByteStringPrinter : public boost::static_visitor<std::string>
{
    
    std::string encoding;
public: 
    ByteStringPrinter(std::string enc) : encoding(enc) {}
    
    std::string operator()(const std::string& s) const
    {
        return s;
    }
    
    std::string operator()(const std::vector<unsigned char>& vector) const
    {
        size_t length = vector.size();
        std::string tmp("HEX(");
        tmp += encoding;
        tmp +=")[";

        for(size_t i = 0; i < length; i++)
        {
            char currentChar[6]; 
            sprintf(currentChar, "%02x", vector[i]);
            tmp += std::string(currentChar);
            tmp += " ";
        }

        tmp += "]";

        return tmp;
    }
};


class ByteStringRawPrinter : public boost::static_visitor<std::string>
{
        std::string* output;
public:
        ByteStringRawPrinter(std::string* _output) : output(_output) {}

        ByteStringRawPrinter() : output(0) {}

    std::string operator()(const std::string& s) const
    {
                if(output)
                    *output = s;

        return s;
    }
    
    std::string operator()(const std::vector<unsigned char>& vector) const
    {
            if(output)
            {
                output->assign(vector.begin(), vector.end());
                return *output;
            } else {
                std::string rawData(vector.begin(), vector.end());
                return rawData;
            }
        }
};

struct ByteSequence
{
    std::string encoding;
    fipa::acl::LengthValue length;
    fipa::acl::ByteString bytes;

    std::string toPrettyString() const
    {
        std::string tmp;
        // Since bytes is a variant we apply the visitor pattern here
        tmp += boost::apply_visitor( ByteStringPrinter(encoding), bytes);
        return tmp;
    }

    std::string toRawDataString() const
    {
        std::string tmp;
        // Since bytes is a variant we apply the visitor pattern here
        tmp += boost::apply_visitor( ByteStringRawPrinter(), bytes);
        return tmp;
    }


    void toRawDataString(std::string* output) const
    {
        // Since bytes is a variant we apply the visitor pattern here
        boost::apply_visitor( ByteStringRawPrinter(output), bytes);
    }
};



}} // namespace fipa::acl

#endif