ChaiCoralConverter Class Reference

Converts between CHAI payload containers and CORAL objects: a specification plus per-channel rows, both directions. More...

#include <ChaiCoralConverter.h>

Collaboration diagram for ChaiCoralConverter:

Static Public Member Functions
static coral::AttributeListSpecification *	toCoralSpec (const chai::FieldSpec &fields)
	Build a coral::AttributeListSpecification from a CHAI FieldSpec, one attribute per field in field order.
static chai::FieldSpec	toFieldSpec (const coral::AttributeListSpecification &spec)
	Build a chai::FieldSpec from a coral::AttributeListSpecification, one field per attribute in spec order.
static coral::AttributeList	toAttributeList (const coral::AttributeListSpecification &spec, const chai::Values &values)
	Convert one channel's CHAI Values to a coral::AttributeList, one attribute per field in spec order.
static std::vector< coral::AttributeList >	toAttributeListVec (const coral::AttributeListSpecification &spec, const std::vector< chai::ValuesPtr > &rows)
	Convert one channel's CHAI vector-payload rows to a coral::AttributeList per row, in row order, via toAttributeList().
static chai::ValuesPtr	toValues (chai::FieldSpecPtr fields, const coral::AttributeList &attrList)
	Convert one coral::AttributeList to CHAI Values, one value per field in FieldSpec order.
static std::vector< chai::ValuesPtr >	toValuesVec (chai::FieldSpecPtr fields, const std::vector< coral::AttributeList > &rows)
	Convert a coral::AttributeList per row, in row order, to CHAI Values sharing one FieldSpecPtr, via toValues().
static std::unique_ptr< AthenaAttributeList >	toAthenaAttributeList (const chai::Container &container)
	Convert a chai::Container's single populated channel to an AthenaAttributeList.
static chai::Container	toContainer (const AthenaAttributeList &attrList, uint64_t channelId=0, const std::string &channelName="")
	Convert an AthenaAttributeList to a single-channel chai::Container.
static std::unique_ptr< CondAttrListCollection >	toCondAttrListCollection (const chai::Container &container, bool hasRunLumiBlockTime)
	Convert a chai::Container to a CondAttrListCollection, one row per populated channel.
static chai::Container	toContainer (const CondAttrListCollection &collection)
	Convert a CondAttrListCollection to a chai::Container, one channel per entry with an attribute list.
static unsigned int	valuesSize (const chai::Values &values)
	Total byte size of one channel's field values, using the same type mapping as toAttributeList().
static unsigned int	payloadSize (const chai::Container &container)
	Total byte size of every populated channel in a scalar payload.
static unsigned int	payloadSize (const chai::VectorContainer &container)
	Total byte size of every row of every populated channel in a vector payload.

Detailed Description

Converts between CHAI payload containers and CORAL objects: a specification plus per-channel rows, both directions.

IOV is never read or written, the caller owns that. Container-level conversions only see populated channels (a Values with at least one value pushed). Zero-attribute CORAL specifications are rejected.

Definition at line 44 of file ChaiCoralConverter.h.

Member Function Documentation

payloadSize() [1/2]

unsigned int ChaiCoralConverter::payloadSize ( const chai::Container & container )

static

Total byte size of every populated channel in a scalar payload.

Definition at line 402 of file ChaiCoralConverter.cxx.

                                                                           {
  unsigned int total = 0;
  for (const auto channelId : container.channelIds()) {
    total += valuesSize(container[channelId]);
  }
  return total;
}

payloadSize() [2/2]

unsigned int ChaiCoralConverter::payloadSize ( const chai::VectorContainer & container )

static

Total byte size of every row of every populated channel in a vector payload.

Exceptions

std::invalid_argument

if a row is null, naming its channel and index.

Definition at line 410 of file ChaiCoralConverter.cxx.

                                                                                 {
  unsigned int total = 0;
  for (const auto channelId : container.channelIds()) {
    const auto& rows = container.rows(channelId);
    for (std::size_t i = 0; i != rows.size(); ++i) {
      if (!rows[i]) {
        throw std::invalid_argument(
          "ChaiCoralConverter::payloadSize: null row at channel " + std::to_string(channelId)
          + " index " + std::to_string(i));
      }
      total += valuesSize(*rows[i]);
    }
  }
  return total;
}

toAthenaAttributeList()

std::unique_ptr< AthenaAttributeList > ChaiCoralConverter::toAthenaAttributeList ( const chai::Container & container )

static

Convert a chai::Container's single populated channel to an AthenaAttributeList.

Parameters

container

- the container to convert, with only one populated channel

Returns

A new AthenaAttributeList built from that channel's row.

Exceptions

std::runtime_error

if the container does not have exactly one populated channel, or under the same conditions as toCoralSpec() or toAttributeList() for that channel's row.

Definition at line 303 of file ChaiCoralConverter.cxx.

                                                                                                           {
  const auto ids = container.channelIds();
  if (ids.size() != 1) {
    throw std::runtime_error(
      "ChaiCoralConverter::toAthenaAttributeList: expected exactly one populated channel, found "
      + std::to_string(ids.size()));
  }
  const SpecHolder spec(toCoralSpec(container.fieldSpec()));
  return std::make_unique<AthenaAttributeList>(toAttributeList(*spec, container[ids[0]]));
}

toAttributeList()

coral::AttributeList ChaiCoralConverter::toAttributeList ( const coral::AttributeListSpecification & spec, const chai::Values & values )

static

Convert one channel's CHAI Values to a coral::AttributeList, one attribute per field in spec order.

Null fields map to a null coral::Attribute. Fields are resolved by name, so a payload whose fields are ordered differently than the specification still maps correctly.

Parameters

spec	- the CORAL specification the values are converted against
values	- the CHAI row to convert

Returns

A CORAL attribute list built from the given specification.

Exceptions

std::runtime_error

if the field counts of spec and values differ, if a field name in the specification is not present in values, or on an unrecognised chai::Type.

Definition at line 116 of file ChaiCoralConverter.cxx.

                                                                                   {
  // The specification is built from a tag's first payload, so a later
  // payload with a different field count is caught here
  if (values.size() != spec.size()) {
    throw std::runtime_error("ChaiCoralConverter::toAttributeList: field count mismatch, payload "
                             + std::to_string(values.size()) + " vs specification " + std::to_string(spec.size()));
  }
  coral::AttributeList attr(spec, true);
  const unsigned int s = attr.size();
  for (unsigned int i = 0; i != s; ++i) {
    auto& att = attr[i];
    // Look up each value by name rather than position
    const std::string& fieldName = att.specification().name();
    const std::size_t idx = values.fieldIndex(fieldName);
    if (values.isNull(idx)) {
      att.setNull();
      continue;
    }
    switch (values.type(idx)) {
      case chai::Bool:
        att.setValue<bool>(values.get<bool>(idx));
        break;
      case chai::Int8:
        att.setValue<char>(values.get<int8_t>(idx));
        break;
      case chai::UInt8:
        att.setValue<unsigned char>(values.get<uint8_t>(idx));
        break;
      case chai::Int16:
        att.setValue<short>(values.get<int16_t>(idx));
        break;
      case chai::UInt16:
        att.setValue<unsigned short>(values.get<uint16_t>(idx));
        break;
      case chai::Int32:
        att.setValue<int>(values.get<int32_t>(idx));
        break;
      case chai::UInt32:
        att.setValue<unsigned int>(values.get<uint32_t>(idx));
        break;
      case chai::Int64:
        att.setValue<long long>(values.get<int64_t>(idx));
        break;
      case chai::UInt64:
        att.setValue<unsigned long long>(values.get<uint64_t>(idx));
        break;
      case chai::Float:
        att.setValue<float>(values.get<float>(idx));
        break;
      case chai::Double:
        att.setValue<double>(values.get<double>(idx));
        break;
      case chai::String:
        att.setValue<std::string>(values.get<std::string>(idx));
        break;
      case chai::Blob: {
        const auto& bytes = values.get<chai::BlobData>(idx).m_bytes;
        coral::Blob blob(bytes.size());
        // Skip the memcpy if the blob is empty
        if (!bytes.empty()) {
          std::memcpy(blob.startingAddress(), bytes.data(), bytes.size());
        }
        att.setValue<coral::Blob>(blob);
        break;
      }
      case chai::Unknown: // Fall-through
      default:
        throw std::runtime_error(
          "ChaiCoralConverter::toAttributeList: unrecognised CHAI type for field '" + fieldName + "'");
    }
  }
  return attr;
}

toAttributeListVec()

std::vector< coral::AttributeList > ChaiCoralConverter::toAttributeListVec ( const coral::AttributeListSpecification & spec, const std::vector< chai::ValuesPtr > & rows )

static

Convert one channel's CHAI vector-payload rows to a coral::AttributeList per row, in row order, via toAttributeList().

Parameters

spec	- the CORAL specification every row is converted against
rows	- the CHAI rows to convert

Returns

One CORAL attribute list per row, in row order.

Exceptions

std::invalid_argument	if a row is null, naming its index.
std::runtime_error	under the same conditions as toAttributeList().

Definition at line 191 of file ChaiCoralConverter.cxx.

                                                                                                               {
  std::vector<coral::AttributeList> result;
  result.reserve(rows.size());
  for (std::size_t i = 0; i != rows.size(); ++i) {
    if (!rows[i]) {
      throw std::invalid_argument(
        "ChaiCoralConverter::toAttributeListVec: null row at index " + std::to_string(i));
    }
    result.push_back(toAttributeList(spec, *rows[i]));
  }
  return result;
}

toCondAttrListCollection()

std::unique_ptr< CondAttrListCollection > ChaiCoralConverter::toCondAttrListCollection ( const chai::Container & container, bool hasRunLumiBlockTime )

static

Convert a chai::Container to a CondAttrListCollection, one row per populated channel.

Named channels get their name added.

Parameters

container	- the container to convert
hasRunLumiBlockTime	- passed through to CondAttrListCollection's constructor

Returns

A new CondAttrListCollection.

Exceptions

std::runtime_error

if a populated channel id exceeds CondAttrListCollection::ChanNum's range, or under the same conditions as toCoralSpec() or toAttributeList() for any channel's row.

Definition at line 326 of file ChaiCoralConverter.cxx.

                                                              {
  const SpecHolder spec(toCoralSpec(container.fieldSpec()));
  auto collection = std::make_unique<CondAttrListCollection>(hasRunLumiBlockTime);
  const auto names = container.channelSpec().channelNames();
  for (const auto id : container.channelIds()) {
    // Catch IDs too wide for ChanNum before the cast truncates them
    if (id > std::numeric_limits<CondAttrListCollection::ChanNum>::max()) {
      throw std::runtime_error(
        "ChaiCoralConverter::toCondAttrListCollection: channel id " + std::to_string(id)
        + " exceeds ChanNum range");
    }
    const auto chan = static_cast<CondAttrListCollection::ChanNum>(id);
    collection->addShared(chan, toAttributeList(*spec, container[id]));
    const auto nameIt = names.find(id);
    if (nameIt != names.end() && !nameIt->second.empty()) {
      collection->add(chan, nameIt->second);
    }
  }
  return collection;
}

toContainer() [1/2]

chai::Container ChaiCoralConverter::toContainer ( const AthenaAttributeList & attrList, uint64_t channelId = 0, const std::string & channelName = "" )

static

Convert an AthenaAttributeList to a single-channel chai::Container.

Parameters

attrList	- the row to convert
channelId	- the channel id to assign the row to
channelName	- the channel name to assign

Returns

A new container with one populated channel.

Exceptions

std::runtime_error

if attrList's specification has zero attributes, or under the same conditions as toFieldSpec() or toValues().

Definition at line 314 of file ChaiCoralConverter.cxx.

                                                                              {
  const coral::AttributeListSpecification& coralSpec = attrList.specification();
  if (coralSpec.size() == 0) {
    throw std::runtime_error("ChaiCoralConverter::toContainer: zero-attribute specification");
  }
  const auto fields = std::make_shared<const chai::FieldSpec>(toFieldSpec(coralSpec));
  chai::Container container(chai::PayloadSpec(*fields, chai::ChannelSpec({{channelId, channelName}})));
  container.add(channelId, toValues(fields, attrList));
  return container;
}

toContainer() [2/2]

chai::Container ChaiCoralConverter::toContainer ( const CondAttrListCollection & collection )

static

Convert a CondAttrListCollection to a chai::Container, one channel per entry with an attribute list.

Named channels keep their name.

Parameters

collection

- the collection to convert

Returns

A new Container.

Exceptions

std::runtime_error

if the collection is empty, if its shared specification has zero attributes, or under the same conditions as toFieldSpec() or toValues() for any channel.

Definition at line 348 of file ChaiCoralConverter.cxx.

                                                                                      {
  if (collection.size() == 0) {
    throw std::runtime_error("ChaiCoralConverter::toContainer: empty collection");
  }
  const coral::AttributeListSpecification& coralSpec = collection.begin()->second.specification();
  if (coralSpec.size() == 0) {
    throw std::runtime_error("ChaiCoralConverter::toContainer: zero-attribute specification");
  }
  // Container fixes its channel set at construction, so names are collected before building it
  std::map<uint64_t, std::string> channelNames;
  for (const auto& pair : collection) {
    channelNames[static_cast<uint64_t>(pair.first)] = collection.chanName(pair.first);
  }
  const auto fields = std::make_shared<const chai::FieldSpec>(toFieldSpec(coralSpec));
  chai::Container container(chai::PayloadSpec(*fields, chai::ChannelSpec(channelNames)));
  for (const auto& [chan, attrList] : collection) {
    const uint64_t id = chan;
    container.add(id, toValues(fields, attrList));
  }
  return container;
}

toCoralSpec()

coral::AttributeListSpecification * ChaiCoralConverter::toCoralSpec ( const chai::FieldSpec & fields )

static

Build a coral::AttributeListSpecification from a CHAI FieldSpec, one attribute per field in field order.

See the type table above toCoralSpec()'s definition for the chai::Type <-> CORAL type mapping.

Parameters

fields

- the field specification to convert

Returns

A new specification. CORAL refcounts specifications so the caller must release it

Exceptions

std::runtime_error

on an unrecognised chai::Type.

Definition at line 74 of file ChaiCoralConverter.cxx.

                                                                                            {
  auto* pSpec = new coral::AttributeListSpecification();
  try {
    for (const auto& field : fields.fields()) {
      switch (field.type) {
        case chai::Bool:   pSpec->extend(field.name, typeid(bool)); break;
        case chai::Int8:   pSpec->extend(field.name, typeid(char)); break;
        case chai::UInt8:  pSpec->extend(field.name, typeid(unsigned char)); break;
        case chai::Int16:  pSpec->extend(field.name, typeid(short)); break;
        case chai::UInt16: pSpec->extend(field.name, typeid(unsigned short)); break;
        case chai::Int32:  pSpec->extend(field.name, typeid(int)); break;
        case chai::UInt32: pSpec->extend(field.name, typeid(unsigned int)); break;
        case chai::Int64:  pSpec->extend(field.name, typeid(long long)); break;
        case chai::UInt64: pSpec->extend(field.name, typeid(unsigned long long)); break;
        case chai::Float:  pSpec->extend(field.name, typeid(float)); break;
        case chai::Double: pSpec->extend(field.name, typeid(double)); break;
        case chai::String: pSpec->extend(field.name, typeid(std::string)); break;
        case chai::Blob:   pSpec->extend(field.name, typeid(coral::Blob)); break;
        case chai::Unknown: // Fall-through
        default:
          throw std::runtime_error(
            "ChaiCoralConverter::toCoralSpec: unrecognised CHAI type for field '" + field.name + "'");
      }
    }
  } catch (...) {
    pSpec->release();
    throw;
  }
  return pSpec;
}

toFieldSpec()

chai::FieldSpec ChaiCoralConverter::toFieldSpec ( const coral::AttributeListSpecification & spec )

static

Build a chai::FieldSpec from a coral::AttributeListSpecification, one field per attribute in spec order.

See the type table above toCoralSpec()'s definition for the chai::Type <-> CORAL type mapping.

Parameters

spec	- the CORAL specification to convert

Returns

An equivalent CHAI field specification

Exceptions

std::runtime_error

if an attribute's CORAL type has no CHAI equivalent

Definition at line 105 of file ChaiCoralConverter.cxx.

                                                                                         {
  std::vector<chai::Field> fields;
  fields.reserve(spec.size());
  const unsigned int s = spec.size();
  for (unsigned int i = 0; i != s; ++i) {
    const auto& attrSpec = spec[i];
    fields.push_back({attrSpec.name(), chaiTypeFor(attrSpec)});
  }
  return chai::FieldSpec(std::move(fields));
}

toValues()

chai::ValuesPtr ChaiCoralConverter::toValues ( chai::FieldSpecPtr fields, const coral::AttributeList & attrList )

static

Convert one coral::AttributeList to CHAI Values, one value per field in FieldSpec order.

Null attributes map to a null CHAI value. Fields are resolved by name, so an attribute list whose fields are ordered differently than the FieldSpec still maps correctly.

Parameters

fields	- the field specification the row shares with its siblings
attrList	- the CORAL row to convert

Returns

A CHAI row built against the given field specification.

Exceptions

std::invalid_argument	if fields is null.
std::runtime_error	if the field counts of fields and attrList differ, if a field name in fields is not present in attrList, if a field's CORAL type doesn't match its chai::Type, or on an unrecognised CORAL type.

Definition at line 205 of file ChaiCoralConverter.cxx.

                                                                                                      {
  if (!fields) {
    throw std::invalid_argument("ChaiCoralConverter::toValues: null field specification");
  }
  if (fields->size() != attrList.size()) {
    throw std::runtime_error("ChaiCoralConverter::toValues: field count mismatch, specification "
                             + std::to_string(fields->size()) + " vs payload " + std::to_string(attrList.size()));
  }
  auto values = std::make_shared<chai::Values>(fields);
  const std::size_t n = fields->size();
  for (std::size_t i = 0; i != n; ++i) {
    const chai::Field& field = (*fields)[i];
    const int idx = attrList.specification().index(field.name);
    if (idx < 0) {
      throw std::runtime_error(
        "ChaiCoralConverter::toValues: field '" + field.name + "' not found in payload");
    }
    const auto& att = attrList[static_cast<unsigned int>(idx)];
    const chai::Type payloadType = chaiTypeFor(att.specification());
    if (payloadType != field.type) {
      throw std::runtime_error(
        "ChaiCoralConverter::toValues: type mismatch for field '" + field.name + "': specification "
        + field.typeString() + " vs payload " + chai::typeToString(payloadType));
    }
    if (att.isNull()) {
      values->push();
      continue;
    }
    // Have to cast to the exact fixed-width types for integers since push is templated
    switch (field.type) {
      case chai::Bool:
        values->push(att.data<bool>());
        break;
      case chai::Int8:
        values->push(static_cast<int8_t>(att.data<char>()));
        break;
      case chai::UInt8:
        values->push(static_cast<uint8_t>(att.data<unsigned char>()));
        break;
      case chai::Int16:
        values->push(static_cast<int16_t>(att.data<short>()));
        break;
      case chai::UInt16:
        values->push(static_cast<uint16_t>(att.data<unsigned short>()));
        break;
      case chai::Int32:
        values->push(static_cast<int32_t>(att.data<int>()));
        break;
      case chai::UInt32:
        values->push(static_cast<uint32_t>(att.data<unsigned int>()));
        break;
      case chai::Int64:
        values->push(static_cast<int64_t>(att.data<long long>()));
        break;
      case chai::UInt64:
        values->push(static_cast<uint64_t>(att.data<unsigned long long>()));
        break;
      case chai::Float:
        values->push(att.data<float>());
        break;
      case chai::Double:
        values->push(att.data<double>());
        break;
      case chai::String:
        values->push(att.data<std::string>());
        break;
      case chai::Blob: {
        const coral::Blob& blob = att.data<coral::Blob>();
        std::vector<uint8_t> bytes(blob.size());
        // Skip the memcpy if the blob is empty
        if (blob.size() != 0) {
          std::memcpy(bytes.data(), blob.startingAddress(), blob.size());
        }
        values->push(chai::BlobData(std::move(bytes)));
        break;
      }
      case chai::Unknown: // Fall-through
      default:
        throw std::runtime_error(
          "ChaiCoralConverter::toValues: unrecognised CHAI type for field '" + field.name + "'");
    }
  }
  return values;
}

toValuesVec()

std::vector< chai::ValuesPtr > ChaiCoralConverter::toValuesVec ( chai::FieldSpecPtr fields, const std::vector< coral::AttributeList > & rows )

static

Convert a coral::AttributeList per row, in row order, to CHAI Values sharing one FieldSpecPtr, via toValues().

Parameters

fields	- the field specification every row is converted against
rows	- the CORAL rows to convert

Returns

One CHAI row per input row, in row order.

Exceptions

std::invalid_argument	if fields is null.
std::runtime_error	under the same conditions as toValues().

Definition at line 290 of file ChaiCoralConverter.cxx.

                                                                                                        {
  if (!fields) {
    throw std::invalid_argument("ChaiCoralConverter::toValuesVec: null field specification");
  }
  std::vector<chai::ValuesPtr> result;
  result.reserve(rows.size());
  for (std::size_t i = 0; i != rows.size(); ++i) {
    result.push_back(toValues(fields, rows[i]));
  }
  return result;
}

valuesSize()

unsigned int ChaiCoralConverter::valuesSize ( const chai::Values & values )

static

Total byte size of one channel's field values, using the same type mapping as toAttributeList().

Fixed-width for scalar types; the actual length for String/Blob. Null fields count as zero bytes.

Definition at line 370 of file ChaiCoralConverter.cxx.

                                                                    {
  unsigned int total = 0;
  const std::size_t n = values.size();
  for (std::size_t i = 0; i != n; ++i) {
    if (values.isNull(i)) continue;
    switch (values.type(i)) {
      case chai::Bool:   total += sizeof(bool);     break;
      case chai::Int8:   total += sizeof(int8_t);   break;
      case chai::UInt8:  total += sizeof(uint8_t);  break;
      case chai::Int16:  total += sizeof(int16_t);  break;
      case chai::UInt16: total += sizeof(uint16_t); break;
      case chai::Int32:  total += sizeof(int32_t);  break;
      case chai::UInt32: total += sizeof(uint32_t); break;
      case chai::Int64:  total += sizeof(int64_t);  break;
      case chai::UInt64: total += sizeof(uint64_t); break;
      case chai::Float:  total += sizeof(float);    break;
      case chai::Double: total += sizeof(double);   break;
      case chai::String:
        total += values.get<std::string>(i).size();
        break;
      case chai::Blob:
        total += values.get<chai::BlobData>(i).m_bytes.size();
        break;
      case chai::Unknown: // Fall-through
      default:
        throw std::runtime_error(
          "ChaiCoralConverter::valuesSize: unrecognised CHAI type at field index " + std::to_string(i));
    }
  }
  return total;
}

---

The documentation for this class was generated from the following files:

• ChaiCoralConverter.h
• ChaiCoralConverter.cxx