binpac_bytestring.h

#ifndef binpac_bytestring_h
#define binpac_bytestring_h

#include <string.h>
#include <string>

#include "binpac.h"

namespace binpac {

template<class T>
class datastring;

template<class T>
class const_datastring {
public:
    const_datastring() : begin_(0), end_(0) {}

    const_datastring(T const* data, int length) : begin_(data), end_(data + length) {}

    const_datastring(const T* begin, const T* end) : begin_(begin), end_(end) {}

    const_datastring(datastring<T> const& s) : begin_(s.begin()), end_(s.end()) {}

    void init(const T* data, int length) {
        begin_ = data;
        end_ = data + length;
    }

    T const* begin() const { return begin_; }
    T const* end() const { return end_; }
    int length() const { return end_ - begin_; }

    T const& operator[](int index) const { return begin()[index]; }

    bool operator==(const_datastring<T> const& s) {
        if ( length() != s.length() )
            return false;
        return memcmp((const void*)begin(), (const void*)s.begin(), sizeof(T) * length()) == 0;
    }

    void set_begin(T const* begin) { begin_ = begin; }
    void set_end(T const* end) { end_ = end; }

private:
    T const* begin_;
    T const* end_;
};

typedef const_datastring<uint8> const_bytestring;

template<class T>
class datastring {
public:
    datastring() { clear(); }

    datastring(T* data, int len) { set(data, len); }

    datastring(T const* begin, T const* end) { set_const(begin, end - begin); }

    datastring(datastring<T> const& x) : data_(x.data()), length_(x.length()) {}

    explicit datastring(const_datastring<T> const& x) { set_const(x.begin(), x.length()); }

    datastring const& operator=(datastring<T> const& x) {
        BINPAC_ASSERT(! data_);
        set(x.data(), x.length());
        return *this;
    }

    void init(T const* begin, int length) {
        BINPAC_ASSERT(! data_);
        set_const(begin, length);
    }

    void clear() {
        data_ = 0;
        length_ = 0;
    }

    void free() {
        if ( data_ )
            delete[] data_;
        clear();
    }

    void clone() { set_const(begin(), length()); }

    datastring const& operator=(const_datastring<T> const& x) {
        BINPAC_ASSERT(! data_);
        set_const(x.begin(), x.length());
        return *this;
    }

    T const& operator[](int index) const { return begin()[index]; }

    T* data() const { return data_; }
    int length() const { return length_; }

    T const* begin() const { return data_; }
    T const* end() const { return data_ + length_; }

private:
    void set(T* data, int len) {
        data_ = data;
        length_ = len;
    }

    void set_const(T const* data, int len) {
        length_ = len;
        data_ = new T[len + 1];
        memcpy(data_, data, sizeof(T) * len);
        data_[len] = 0;
    }

    T* data_;
    int length_;
};

typedef datastring<uint8> bytestring;

inline const char* c_str(bytestring const& s) { return (const char*)s.begin(); }

inline std::string std_str(const_bytestring const& s) {
    return std::string((const char*)s.begin(), (const char*)s.end());
}

inline bool operator==(bytestring const& s1, const char* s2) { return strcmp(c_str(s1), s2) == 0; }

inline void get_pointers(const_bytestring const& s, uint8 const** pbegin, uint8 const** pend) {
    *pbegin = s.begin();
    *pend = s.end();
}

inline void get_pointers(bytestring const* s, uint8 const** pbegin, uint8 const** pend) {
    *pbegin = s->begin();
    *pend = s->end();
}

} // namespace binpac

#endif // binpac_bytestring_h