opaque_data_tuple.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 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 <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 {
        LENGTH_EMPTY = -1,
        LENGTH_1_BYTE,
        LENGTH_2_BYTES
    };
 
    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