// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

#ifndef BUTIL_RAW_PACK_H

#define BUTIL_RAW_PACK_H

#include "butil/sys_byteorder.h"

namespace butil {

// -------------------------------------------------------------------------

// NOTE: RawPacker/RawUnpacker is used for packing/unpacking low-level and

// hard-to-change header. If the fields are likely to be changed in future,

// use protobuf.

// -------------------------------------------------------------------------

// This utility class packs 32-bit and 64-bit integers into binary data 

// that can be unpacked by RawUnpacker. Notice that the packed data is 

// schemaless and user must match pack..() methods with same-width 

// unpack..() methods to get the integers back.

// Example:

//   char buf[16];  // 4 + 8 + 4 bytes.

//   butil::RawPacker(buf).pack32(a).pack64(b).pack32(c);  // buf holds packed data

//

//   ... network ...

//

//   // positional correspondence with pack..()

//   butil::Unpacker(buf2).unpack32(a).unpack64(b).unpack32(c);

class RawPacker {

public:

    // Notice: User must guarantee `stream' is as long as the packed data.

    explicit RawPacker(void* stream) : _stream((char*)stream) {}

    ~RawPacker() {}

    // Not using operator<< because some values may be packed differently from

    // its type.

    RawPacker& pack32(uint32_t host_value) {

        *(uint32_t*)_stream = HostToNet32(host_value);

        _stream += 4;

        return *this;

    }

    RawPacker& pack64(uint64_t host_value) {

        uint32_t *p = (uint32_t*)_stream;

        p[0] = HostToNet32(host_value >> 32);

        p[1] = HostToNet32(host_value & 0xFFFFFFFF);

        _stream += 8;

        return *this;

    }

private:

    char* _stream;

};

// This utility class unpacks 32-bit and 64-bit integers from binary data

// packed by RawPacker.

class RawUnpacker {

public:

    explicit RawUnpacker(const void* stream) : _stream((const char*)stream) {}

    ~RawUnpacker() {}

    RawUnpacker& unpack32(uint32_t & host_value) {

        host_value = NetToHost32(*(const uint32_t*)_stream);

        _stream += 4;

        return *this;

    }

    RawUnpacker& unpack64(uint64_t & host_value) {

        const uint32_t *p = (const uint32_t*)_stream;

        host_value = (((uint64_t)NetToHost32(p[0])) << 32) | NetToHost32(p[1]);

        _stream += 8;

        return *this;

    }

private:

    const char* _stream;

};

}  // namespace butil

#endif  // BUTIL_RAW_PACK_H