PackedArray.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "CxxUtils/PackedArray.h"
#include "CxxUtils/throw_out_of_range.h"
#include <stdexcept>
#include <climits>
#include <cassert>
 
 
namespace {
 

const int nper = sizeof (unsigned int) * CHAR_BIT;
 

inline
CxxUtils::PackedArray::value_type mask (size_t sz)
{
  return (1<<sz) - 1;
}
 
 
} // anonymous namespace
 
 
namespace CxxUtils {
 

inline
PackedArray::size_type PackedArray::nbase (size_type n) const
{
  return (n * m_bitsize + nper-1) / nper;
}
 

inline
PackedArray::size_type PackedArray::tondx (size_type n) const
{
  return (n * m_bitsize) / nper;
}
 

inline
int PackedArray::tooff (size_type n) const
{
  return (n * m_bitsize) % nper;
}
 

inline
PackedArray::value_type PackedArray::doget (size_type ndx, int off) const
{
  // Get the bits from the first entry.
  value_type v = m_vec[ndx] >> off;
 
  // If the packed entry wraps between two base entries, collect the bits
  // from the next base entry.
  if (m_bitsize > nper - off) {
    int bits = m_bitsize - (nper - off);
    // cppcheck-suppress shiftTooManyBits; false positive
    //    m_bitsize <= nper
    v |= ((m_vec[ndx+1] & mask(bits)) << (nper - off));
  }
 
  // Mask down to the proper number of bits.
  return v & m_mask;
}
 

inline
void PackedArray::doset (size_type ndx, int off, value_type v)
{
  // Set the bits in the first entry.
  m_vec[ndx] = (m_vec[ndx] & ~(m_mask<<off)) | ((v&m_mask) << off);
 
  // If the packed entry wraps between two base entries, set the bits
  // in the next entry.
  if (m_bitsize > nper - off) {
    value_type mask2 = mask (m_bitsize - (nper - off));
    m_vec[ndx+1] = (m_vec[ndx+1] & ~mask2) | ((v >> (nper - off)) & mask2);
  }
}
 

void PackedArray::range_check (size_type n) const
{
  if (n >= m_size) {
    throw_out_of_range (__PRETTY_FUNCTION__, n, m_size, this);
  }
}
 

PackedArray::PackedArray (int bitsize,
                          const allocator_type& allocator/*=allocator_type()*/)
  : m_bitsize (bitsize),
    m_size (0),
    m_mask  (mask (bitsize)),
    m_vec (allocator)
{
  assert (m_bitsize > 0 && m_bitsize <= nper);
}
 

PackedArray::PackedArray (int bitsize,
                          size_type n,
                          value_type val /*= 0*/,
                          const allocator_type& allocator/*=allocator_type()*/)
  : m_bitsize (bitsize),
    m_size (n),
    m_mask  (mask (bitsize)),
    m_vec (nbase(n), 0, allocator)
{
  assert (m_bitsize > 0 && m_bitsize <= nper);
  if (val != 0) {
    for (size_type i = 0; i < n; i++)
      set (i, val);
  }
}
 

void PackedArray::assign (size_type n, value_type u /*= 0*/)
{
  m_size = n;
  m_vec.clear();
  m_vec.resize (nbase(n));
  if (u != 0) {
    for (size_type i = 0; i < n; i++)
      set (i, u);
  }
}
 

PackedArray::allocator_type PackedArray::get_allocator() const
{
  return m_vec.get_allocator();
}
 

PackedArray::size_type PackedArray::size() const
{
  return m_size;
}
 

PackedArray::size_type PackedArray::max_size() const
{
  return m_vec.max_size();
}
 

PackedArray::size_type PackedArray::capacity() const
{
  return m_vec.capacity() * nper / m_bitsize;
}
 

void PackedArray::resize (size_type sz, value_type c /*= 0*/)
{
  m_vec.resize (nbase (sz));
  if (sz > m_size) {
    // Making the container bigger.  Need to fill the remaining values.
    if (c != 0) {
      // Set them to something non-zero.
      for (size_t i = m_size; i < sz; i++)
        set (i, c);
    }
    else {
      // Filling the new entries with 0.
      // New elements in the base vector will have been set to 0.
      // However, we also need to zero out any remaining packed elements
      // (or piece thereof) in the last base element that was occupied
      // before the resize.
      int off = tooff (m_size);
      // Don't need to do anything if packed entries exactly fit
      // in the allocated base size.
      if (off != 0) {
        size_t ndx = tondx (m_size);
        m_vec[ndx] &= mask (off);
      }
    }
  }
  m_size = sz;
}
 

bool PackedArray::empty() const
{
  return m_size == 0;
}
 

void PackedArray::reserve (size_type n)
{
  m_vec.reserve (nbase (n));
}
 

PackedArray::value_type PackedArray::get (size_type n) const
{
  return doget (tondx (n), tooff (n));
}
 

void PackedArray::set (size_type n, value_type val)
{
  return doset (tondx (n), tooff (n), val);
}
 

PackedArray::value_type PackedArray::operator[] (size_type n) const
{
  return doget (tondx (n), tooff (n));
}
 

PackedArray::proxy PackedArray::operator[] (size_type n)
{
  return proxy (*this, n);
}
 

PackedArray::value_type PackedArray::at (size_type n) const
{
  range_check (n);
  return doget (tondx (n), tooff (n));
}
 

PackedArray::proxy PackedArray::at (size_type n)
{
  range_check (n);
  return proxy (*this, n);
}
 

PackedArray::value_type PackedArray::front () const
{
  return doget (0, 0);
}
 

PackedArray::value_type PackedArray::back () const
{
  return doget (tondx (m_size-1), tooff (m_size-1));
}
 

PackedArray::proxy PackedArray::front ()
{
  return proxy (*this, 0);
}
 

PackedArray::proxy PackedArray::back ()
{
  return proxy (*this, m_size-1);
}
 

void PackedArray::push_back (value_type x)
{
  ++m_size;
  size_t nb = nbase (m_size);
  if (nb != m_vec.size())
    m_vec.resize (nb);
  doset (tondx (m_size-1), tooff (m_size-1), x);
}
 

void PackedArray::pop_back ()
{
  --m_size;
  size_t nb = nbase (m_size);
  if (nb != m_vec.size())
    m_vec.resize (nb);
}
 

void PackedArray::swap (PackedArray& other)
{
  std::swap (m_bitsize, other.m_bitsize);
  std::swap (m_size,    other.m_size);
  std::swap (m_mask,    other.m_mask);
  std::swap (m_vec,     other.m_vec);
}
 

void PackedArray::clear ()
{
  m_size = 0;
  m_vec.clear();
}
 

void PackedArray::set_bitsize (int bitsize)
{
  assert (m_size == 0);
  assert (bitsize > 0 && bitsize <= nper);
  m_bitsize = bitsize;
  m_mask = mask (bitsize);
}
 

int PackedArray::bitsize () const
{
  return m_bitsize;
}
 
 
} // namespace CxxUtils