Function DictEncode

be/src/util/bit-packing-test.cc:208–246

// used.
template <typename T>
std::pair<std::vector<T>, std::vector<uint8_t>>
DictEncode(const std::vector<T>& input, int bit_width) {
  // Create dictionary and indices.
  std::unordered_map<T, std::size_t> index_map;

  std::vector<T> dict;
  std::vector<uint64_t> indices;

  for (const T value : input) {
    auto it = index_map.find(value);
    if (it != index_map.end()) {
      indices.push_back(it->second);
    } else {
      const std::size_t next_index = dict.size();
      index_map[value] = next_index;
      dict.push_back(value);
      indices.push_back(next_index);
    }
  }

  // Bit pack the indices.
  const int bytes_required = BitUtil::RoundUpNumBytes(bit_width * input.size());
  std::vector<uint8_t> out_data(bytes_required);

  // We do not write data if we do not have any. Doing it could also lead to undefined
  // behaviour as out_data.data() may be nullptr and BitWriter uses memcpy internally, and
  // passing a null pointer to memcpy is undefined behaviour.
  if (bytes_required > 0) {
    BitWriter writer(out_data.data(), bytes_required);
    if (bit_width > 0) {
      for (const uint64_t index : indices) {
        EXPECT_TRUE(writer.PutValue(index, bit_width));
      }
    }
    writer.Flush();
  }

  return std::make_pair(dict, out_data);
}

template <typename T>
void ExpectEqualsWithStride(const T* expected, int num_values,