slice.h

#pragma once
#include <string.h>
#include <string>
#include <vector>

namespace netlib {

class Slice {
public:
    Slice() : pb_("") { pe_ = pb_; }
    Slice(const char* b, const char* e):pb_(b), pe_(e) {}
    Slice(const char* d, size_t n) : pb_(d), pe_(d + n) { }
    Slice(const std::string& s) : pb_(s.data()), pe_(s.data() + s.size()) { }
    Slice(const char* s) : pb_(s), pe_(s + strlen(s)) { }

    const char* data() const { return pb_; }
    const char* begin() const { return pb_; }
    const char* end() const { return pe_; }
    char front() { return *pb_; }
    char back() { return pe_[-1]; }
    size_t size() const { return pe_ - pb_; }
    void resize(size_t sz) { pe_ = pb_ + sz; }
    inline bool empty() const { return pe_ == pb_; }
    void clear() { pe_ = pb_ = ""; }
    
    //return the eated data
    Slice eatWord();
    Slice eatLine();
    Slice eat(int sz) { Slice s(pb_, sz); pb_+=sz; return s; }
    Slice sub(int boff, int eoff=0) const { Slice s(*this); s.pb_ += boff; s.pe_ += eoff; return s; }
    Slice& trimSpace();

    inline char operator[](size_t n) const { return pb_[n]; }

    std::string toString() const { return std::string(pb_, pe_); }
    // Three-way comparison.  Returns value:
    int compare(const Slice& b) const;

    // Return true if "x" is a prefix of "*this"
    bool starts_with(const Slice& x) const {
        return (size() >= x.size() && memcmp(pb_, x.pb_, x.size()) == 0); 
    }

    bool end_with(const Slice& x) const {
        return (size() >= x.size() && memcmp(pe_ - x.size(), x.pb_, x.size()) == 0); 
    }
    operator std::string() const { return std::string(pb_, pe_); }
    std::vector<Slice> split(char ch) const ;
private:
    const char* pb_;
    const char* pe_;
};

inline Slice Slice::eatWord() {
    const char* b = pb_;
    while (b < pe_ && isspace(*b)) {
        b++;
    }
    const char* e = b;
    while (e < pe_ && !isspace(*e)) {
        e ++;
    }
    pb_ = e;
    return Slice(b, e-b);
}

inline Slice Slice::eatLine() { 
    const char* p = pb_; 
    while (pb_<pe_ && *pb_ != '\n' && *pb_!='\r') {
        pb_++; 
    }
    return Slice(p, pb_-p); 
}

inline Slice& Slice::trimSpace() {
    while (pb_ < pe_ && isspace(*pb_)) pb_ ++;
    while (pb_ < pe_ && isspace(pe_[-1])) pe_ --;
    return *this;
}

inline bool operator < (const Slice& x, const Slice& y) {
    return x.compare(y) < 0;
}

inline bool operator==(const Slice& x, const Slice& y) {
    return ((x.size() == y.size()) &&
        (memcmp(x.data(), y.data(), x.size()) == 0));
}

inline bool operator!=(const Slice& x, const Slice& y) {
    return !(x == y);
}

inline int Slice::compare(const Slice& b) const {
    size_t sz = size(), bsz = b.size();
    const int min_len = (sz < bsz) ? sz : bsz;
    int r = memcmp(pb_, b.pb_, min_len);
    if (r == 0) {
        if (sz < bsz) r = -1;
        else if (sz > bsz) r = +1;
    }
    return r;
}

inline std::vector<Slice> Slice::split(char ch) const {
    std::vector<Slice> r;
    const char* pb = pb_;
    for (const char* p = pb_; p < pe_; p++) {
        if (*p == ch) {
            r.push_back(Slice(pb, p));
            pb = p+1;
        }
    }
    if (pe_ != pb_)
        r.push_back(Slice(pb, pe_));
    return r;
}

}