Ping deser

a fake deserializer for quic

object ping_deser = {}

<<< member

    class `ping_deser`;

>>>

<<< impl

    class `ping_deser` : public ivy_binary_deser_128 {
        enum {ping_s_init,
              ping_s_frame,
              ping_s_time,
              ping_s_payload} state;
        int token_length = 4;
        long frame_type;
        int fence=0;
        int current_ping_size = 0;
        int payload_length = 12;

    public:
        ping_deser(const std::vector<char> &inp) : ivy_binary_deser_128(inp),state(ping_s_init) {
        }
        virtual void  get(int128_t &res) {
            switch (state) {
            case ping_s_init:
            {
                std::cerr << "ping_s_init 1\n";
                state = ping_s_payload;
            }
            break;
            case ping_s_frame:
            {
                std::cerr << "ping_s_frame 1\n";
                getn(res,1);
                std::cerr << "payload_length = " << payload_length << "\n";
                //state = ping_s_time;
            }
            break;
            case ping_s_time:
            {
                std::cerr << "ping_s_time 1\n";
                int128_t res_inter = 0;
                getn(res_inter,8);
                res = reverse_bytes(res_inter);
                payload_length -= 8;
                std::cerr << "payload_length = " << payload_length << "\n";
            }
            break;
            default:
                std::cerr << "ping_deser 3\n";
                throw deser_err();
            }
        }


        int128_t reverse_bytes(int128_t bytes)
        {
            int128_t aux = 0;
            uint8_t byte;
            int i;

            for(i = 0; i < 128; i+=8)
            {
                byte = (bytes >> i) & 0xff;
                aux |= byte << (128 - 8 - i);
            }
            return aux;
        }

        virtual int open_tag(const std::vector<std::string> &tags) {
            if (state == ping_s_payload || state == ping_s_init) {
                int128_t ft;
                ivy_binary_deser_128::getn(ft,1); // could be bigger
                frame_type = ft;
                std::cerr << "recv frame_type = " << frame_type << "\n";
                if (frame_type == 0x01) {
                    std::cerr << "ping_s_frame 2\n";
                    state = ping_s_frame;
                    return 0;
                }
                if (frame_type == 0x02) { //JF
                    std::cerr << "ping_s_frame 3\n";
                    state = ping_s_frame;
                    return 1;
                }
                if (frame_type == 0x03) {
                    std::cerr << "ping_s_time 4\n";
                    state = ping_s_time;
                    return 2;
                }
                //std::cerr << "saw tag " << ft << "\n";
            }
            std::cerr << "state          = " << state << "\n";
            std::cerr << "ping_deser 2\n";
            throw deser_err();
        }

        virtual bool open_list_elem() {
            if (state == ping_s_payload) {
                std::cerr << "ping_s_payload ping_deser 2\n";
                //state = ping_s_time;
                return payload_length-->  0;
            }
                //return more(1);
            if ( state == ping_s_frame || state == ping_s_init) {
                 std::cerr << "ping_s_init ping_deser 2\n";
                if (current_ping_size == 5) {
                    //state = ping_s_time;
                    return false;
                }
                current_ping_size += 1;
                payload_length -= 1;
                return true;
            }
            if(state == ping_s_time){
                std::cerr << "ping_s_time ping_deser 2\n";
                return false;
            }

            std::cerr << "ping_deser 1\n";
            throw deser_err();
        }

        void open_list() {
        }
        void close_list() {
            if (state == ping_s_payload) {
                state = ping_s_init;
            }
        }
        void close_list_elem() {}

        virtual void close_tag() {
            state = ping_s_payload;
        }

        ~ping_deser(){}
    };

>>>