bit-stream-utils.8byte.h

Go to the documentation of this file.

// Copyright 2012 Cloudera 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.


#ifndef IMPALA_EXPERIMENTS_BIT_STREAM_UTILS_8BYTE_H
#define IMPALA_EXPERIMENTS_BIT_STREAM_UTILS_8BYTE_H

#include <boost/cstdint.hpp>
#include <string.h>
#include "common/compiler-util.h"
#include "common/logging.h"
#include "util/bit-util.h"

namespace impala {

class BitWriter_8byte {
 public:
  BitWriter_8byte(uint8_t* buffer, int buffer_len) :
      buffer_(reinterpret_cast<uint64_t*>(buffer)),
      max_bytes_(buffer_len),
      offset_(0),
      bit_offset_(0) {
    DCHECK_EQ(buffer_len % 8, 0);
  }

  void Clear() {
    offset_ = 0;
    bit_offset_ = 0;
    memset(buffer_, 0, max_bytes_);
  }

  uint8_t* buffer() const { return reinterpret_cast<uint8_t*>(buffer_); }
  int buffer_len() const { return max_bytes_; }

  inline int bytes_written() const {
    return offset_ * 8 + BitUtil::Ceil(bit_offset_, 8);
  }

  bool PutValue(uint64_t v, int num_bits);

  template<typename T>
  bool PutAligned(T v, int num_bits);

  bool PutVlqInt(int32_t v);

  uint8_t* GetNextBytePtr(int num_bytes = 1);

 private:
  uint64_t* buffer_;
  int max_bytes_;
  int offset_;            // Offset into buffer_
  int bit_offset_;        // Offset into current uint64_t
};

class BitReader_8byte {
 public:
  BitReader_8byte(uint8_t* buffer, int buffer_len) :
      buffer_(reinterpret_cast<uint64_t*>(buffer)),
      max_bytes_(buffer_len),
      offset_(0),
      bit_offset_(0) {
    DCHECK_EQ(buffer_len % 8, 0);
  }

  BitReader_8byte() : buffer_(NULL), max_bytes_(0) {}

  template<typename T>
  bool GetValue(int num_bits, T* v);

  template<typename T>
  bool GetAligned(int num_bits, T* v);

  bool GetVlqInt(int32_t* v);

  inline int bytes_left() {
    return max_bytes_ - (offset_ * 8 + BitUtil::Ceil(bit_offset_, 8));
  }

  static const int MAX_VLQ_BYTE_LEN = 5;
 
 private:
  uint64_t* buffer_;
  int max_bytes_;
  int offset_;            // Offset into buffer_
  int bit_offset_;        // Offset into current uint64_t

  inline void Align();
};

}

#endif