opaque_data_tuple.h

Go to the documentation of this file.

// Copyright (C) 2014-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef OPAQUE_DATA_TUPLE_H
#define OPAQUE_DATA_TUPLE_H
 
#include <dhcp/option.h>
#include <util/buffer.h>
 
#include <cstdint>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {

class OpaqueDataTupleError : public Exception {
public:
    OpaqueDataTupleError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 

class OpaqueDataTuple {
public:

    enum LengthFieldType : int16_t {
        LENGTH_EMPTY = -1,
        LENGTH_1_BYTE = 0,
        LENGTH_2_BYTES = 1,
    };

    using Buffer = std::vector<uint8_t>;
    using InputIterator = Buffer::const_iterator;

    OpaqueDataTuple(LengthFieldType length_field_type);

    OpaqueDataTuple(LengthFieldType length_field_type,
                    InputIterator begin,
                    InputIterator end)
        : length_field_type_(length_field_type) {
        unpack(begin, end);
    }

    void append(const char* data, const size_t len) {
        data_.insert(data_.end(), data, data + len);
    }
    void append(const uint8_t* data, const size_t len) {
        data_.insert(data_.end(), data, data + len);
    }
    void append(InputIterator data, const size_t len) {
        data_.insert(data_.end(), data, data + len);
    }

    void append(const std::string& text);

    void assign(const char* data, const size_t len) {
        data_.assign(data, data + len);
    }
    void assign(InputIterator data, const size_t len) {
        data_.assign(data, data + len);
    }

    void assign(const std::string& text);

    void clear();

    bool equals(const std::string& other) const;

    LengthFieldType getLengthFieldType() const {
        return (length_field_type_);
    }

    size_t getLength() const {
        return (data_.size());
    }

    size_t getTotalLength() const {
        return (getDataFieldSize() + getLength());
    }

    const Buffer& getData() const {
        return (data_);
    }

    std::string getText() const;

    void pack(isc::util::OutputBuffer& buf) const;

    void unpack(InputIterator begin, InputIterator end);

    //{@

    OpaqueDataTuple& operator=(const std::string& other);

    bool operator==(const std::string& other) const;

    bool operator!=(const std::string& other);

    int getDataFieldSize() const;
 
private:

    Buffer data_;

    LengthFieldType length_field_type_;
};

typedef boost::shared_ptr<OpaqueDataTuple> OpaqueDataTuplePtr;

std::ostream& operator<<(std::ostream& os, const OpaqueDataTuple& tuple);

std::istream& operator>>(std::istream& is, OpaqueDataTuple& tuple);
 
} // namespace isc::dhcp
} // namespace isc
 
#endif