bytecontainer.h

Go to the documentation of this file.

/* Copyright 2013-present Barefoot Networks, Inc.
 *
 * Licensed 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.
 */
 
/*
 * Antonin Bas (antonin@barefootnetworks.com)
 *
 */
 
 
#ifndef BM_BM_SIM_BYTECONTAINER_H_
#define BM_BM_SIM_BYTECONTAINER_H_
 
#include <vector>
#include <iterator>
#include <string>
 
#include <boost/functional/hash.hpp>
 
#include "short_alloc.h"
 
namespace bm {
 
class ByteContainer {
  static constexpr size_t S = 16u;
  static_assert(sizeof(char) == 1, "");
  static_assert(alignof(char) == 1, "");
  using _vector = std::vector<char, detail::short_alloc<char, S, 1> >;
 
 public:
  using iterator = _vector::iterator;
  using const_iterator = _vector::const_iterator;
  using reference = _vector::reference;
  using const_reference = _vector::const_reference;
  using size_type = size_t;
 
 public:
  ByteContainer()
      : bytes(_a) {
    bytes.reserve(S);
  }
 
  explicit ByteContainer(const size_t nbytes, const char c = '\x00')
      : bytes(nbytes, c, _a) { }
 
  explicit ByteContainer(const std::vector<char> &bytes)
      : bytes(bytes.begin(), bytes.end(), _a) { }
 
  ByteContainer(const char *bytes, size_t nbytes)
      : bytes(bytes, bytes + nbytes, _a) { }
 
  static char char2digit(char c) {
    if (c >= '0' && c <= '9')
      return (c - '0');
    if (c >= 'A' && c <= 'F')
      return (c - 'A' + 10);
    if (c >= 'a' && c <= 'f')
      return (c - 'a' + 10);
    assert(0);
    return 0;
  }
 
  explicit ByteContainer(const std::string &hexstring)
      : bytes(_a) {
    bytes.reserve(S);
    size_t idx = 0;
 
    assert(hexstring[idx] != '-');
 
    if (hexstring[idx] == '0' && hexstring[idx + 1] == 'x') {
      idx += 2;
    }
    size_t size = hexstring.size();
    assert((size - idx) > 0);
 
    if ((size - idx) % 2 != 0) {
      char c = char2digit(hexstring[idx++]);
      bytes.push_back(c);
    }
 
    for (; idx < size; ) {
      char c = char2digit(hexstring[idx++]) << 4;
      c += char2digit(hexstring[idx++]);
      bytes.push_back(c);
    }
  }
 
  ByteContainer(const ByteContainer &other)
      : bytes(other.bytes, _a) { }
 
  ByteContainer &operator=(const ByteContainer &other) {
    bytes.assign(other.begin(), other.end());
    return *this;
  }
 
  size_type size() const noexcept { return bytes.size(); }
 
  void clear() { return bytes.clear(); }
 
  // iterators
 
  iterator begin() { return bytes.begin(); }
 
  const_iterator begin() const { return bytes.begin(); }
 
  iterator end() { return bytes.end(); }
 
  const_iterator end() const { return bytes.end(); }
 
  // reverse_iterator rbegin() { return bytes.rbegin(); }
 
  // const_reverse_iterator rbegin() const { return bytes.rbegin(); }
 
  // reverse_iterator rend() { return bytes.rend(); }
 
  // const_reverse_iterator rend() const { return bytes.rend(); }
 
  // const_iterator cbegin() const { return bytes.cbegin(); }
 
  // const_iterator cend() const { return bytes.cend(); }
 
  // const_reverse_iterator crbegin() const { return bytes.crbegin(); }
 
  // const_reverse_iterator crend() const { return bytes.crend(); }
 
  ByteContainer &append(const ByteContainer &other) {
    bytes.insert(end(), other.begin(), other.end());
    return *this;
  }
 
  ByteContainer &append(const char *byte_array, size_t nbytes) {
    bytes.insert(end(), byte_array, byte_array + nbytes);
    return *this;
  }
 
  ByteContainer &append(const std::string &other) {
    bytes.insert(end(), other.begin(), other.end());
    return *this;
  }
 
  // issue with g++-4.8, insert has a non-conforming signature, fixed in g++-4.9
  // and g++-5.0. However, this signature works for "all" versions
  // iterator insert(const_iterator pos, const ByteContainer& other) {
  void insert(iterator pos, const ByteContainer& other) {
    // return bytes.insert(pos, other.begin(), other.end());
    bytes.insert(pos, other.begin(), other.end());
  }
 
  void push_back(char c) {
    bytes.push_back(c);
  }
 
  reference operator[](size_type n) {
    assert(n < size());
    return bytes[n];
  }
 
  const_reference operator[](size_type n) const {
    assert(n < size());
    return bytes[n];
  }
 
  reference back() {
    return bytes.back();
  }
 
  const_reference back() const {
    return bytes.back();
  }
 
  reference front() {
    return bytes.front();
  }
 
  const_reference front() const {
    return bytes.front();
  }
 
  char* data() noexcept {
    return bytes.data();
  }
 
  const char* data() const noexcept {
    return bytes.data();
  }
 
  bool operator==(const ByteContainer& other) const {
    return bytes == other.bytes;
  }
 
  bool operator!=(const ByteContainer& other) const {
    return !(*this == other);
  }
 
  void reserve(size_t n) {
    bytes.reserve(n);
  }
 
  void resize(size_t n) {
    bytes.resize(n);
  }
 
  void resize(size_t n, char c) {
    bytes.resize(n, c);
  }
 
  void apply_mask(const ByteContainer &mask) {
    assert(size() == mask.size());
    for (size_t i = 0; i < size(); i++)
      bytes[i] &= mask[i];
  }
 
  std::string to_hex(size_t start, size_t s, bool upper_case = false) const;
 
  std::string to_hex(bool upper_case = false) const {
    return to_hex(0, size(), upper_case);
  }
 
 private:
  _vector::allocator_type::arena_type _a;
  _vector bytes;
};
 
struct ByteContainerKeyHash {
  std::size_t operator()(const ByteContainer& b) const {
    // Murmur, boost::hash_range or Jenkins?
    return boost::hash_range(b.begin(), b.end());
  }
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_BYTECONTAINER_H_