CollectionData.cc.jinja2

{% import "macros/utils.jinja2" as utils %}
{% import "macros/collections.jinja2" as macros %}
// AUTOMATICALLY GENERATED FILE - DO NOT EDIT

#include "{{ incfolder }}{{ class.bare_type }}CollectionData.h"
#include "{{ incfolder }}{{ class.bare_type }}Collection.h"

{% for include in includes_coll_cc %}
{{ include }}
{% endfor %}

{{ utils.namespace_open(class.namespace) }}
{% with class_type = class.bare_type + 'CollectionData' %}

{{ class_type }}::{{ class_type }}() :
{% for relation in OneToManyRelations + OneToOneRelations %}
  m_rel_{{ relation.name }}(new std::vector<{{ relation.namespace }}::{{ relation.bare_type }}>()),
{% endfor %}
{%- for member in VectorMembers %}
  m_vec_{{ member.name }}(new std::vector<{{ member.full_type }}>()),
{% endfor %}
  m_data(new {{ class.bare_type }}DataContainer()) {
{% for relation in OneToManyRelations + OneToOneRelations %}
  m_refCollections.emplace_back(std::make_unique<std::vector<podio::ObjectID>>());
{% endfor %}
{% for member in VectorMembers %}
  m_vecmem_info.emplace_back("{{ member.full_type }}", &m_vec_{{ member.name }});
{% endfor %}
}

{{ class_type }}::{{ class_type }}(podio::CollectionReadBuffers buffers, bool isSubsetColl) :
{% for relation in OneToManyRelations + OneToOneRelations %}
  m_rel_{{ relation.name }}(new std::vector<{{ relation.namespace }}::{{ relation.bare_type }}>()),
{% endfor %}
  m_refCollections(std::move(*buffers.references)),
  m_vecmem_info(std::move(*buffers.vectorMembers)) {
  // For subset collections we are done, for proper collections we still have to
  // populate the data and vector members
  if (!isSubsetColl) {
    m_data.reset(buffers.dataAsVector<{{ class.full_type }}Data>());

{% for member in VectorMembers %}
  m_vec_{{ member.name }}.reset(podio::CollectionReadBuffers::asVector<{{ member.full_type }}>(m_vecmem_info[{{ loop.index0 }}].second));
{% endfor %}
  }

  // Cleanup these to avoid leaking them
  delete buffers.references;
  delete buffers.vectorMembers;
}

void {{ class_type }}::clear(bool isSubsetColl) {
  if (isSubsetColl) {
    // We don't own the objects so no cleanup to do here
    entries.clear();
    // Clear the ObjectID I/O buffer
    for (auto& pointer : m_refCollections) { pointer->clear(); }
    return;
  }

  // Normal collections manage a bit more and have to clean up a bit more
  if (m_data) m_data->clear();
{% if OneToManyRelations or OneToOneRelations %}
  for (auto& pointer : m_refCollections) { pointer->clear(); }
{% endif %}
{% for relation in OneToManyRelations %}
  // clear relations to {{ relation.name }}. Make sure to unlink() the reference data as they may be gone already.
  for (auto& pointer : m_rel_{{ relation.name }}_tmp) {
    for (auto& item : *pointer) {
      item.unlink();
    }
  }
  m_rel_{{ relation.name }}_tmp.clear();
{{ macros.clear_relation(relation) }}
{% endfor %}
{% for relation in OneToOneRelations %}
{{ macros.clear_relation(relation) }}
{% endfor %}
{% for member in VectorMembers %}
  if (m_vec_{{ member.name }}) m_vec_{{ member.name }}->clear();
  m_vecs_{{ member.name }}.clear();

{% endfor %}
  for (auto& obj : entries) { delete obj; }
  entries.clear();
}

podio::CollectionWriteBuffers {{ class_type }}::getCollectionBuffers(bool isSubsetColl) {
{% if VectorMembers %}
  if (!isSubsetColl) {
    // Make sure these point to the right place, even if a collection has been
    // moved since it has been created
{% for member in VectorMembers %}
    m_vecmem_info[{{ loop.index0 }}].second = &m_vec_{{ member.name }};
{% endfor %}
  }
{% endif -%}

  return {
    isSubsetColl ? nullptr : (void*)&m_data,
    isSubsetColl ? nullptr : (void*)m_data.get(),
    &m_refCollections, // only need to store the ObjectIDs of the referenced objects
    &m_vecmem_info
  };
}

void {{ class_type }}::prepareForWrite(bool isSubsetColl) {
  for (auto& pointer : m_refCollections) { pointer->clear(); }

  // If this is a subset collection use the relation storing mechanism to
  // store the ObjectIDs of all referenced objects and nothing else
  if (isSubsetColl) {
    for (const auto* obj : entries) {
      m_refCollections[0]->emplace_back(obj->id);
    }
    return;
  }

  // Normal collections have to store the data and all the relations
  m_data->reserve(entries.size());
  for (auto& obj : entries) { m_data->push_back(obj->data); }

{% for relation in OneToManyRelations %}
  int {{ relation.name }}_index = 0;
{% endfor %}
{% for member in VectorMembers %}
const auto {{ member.name }}_size = std::accumulate(entries.begin(), entries.end(), 0,
  [](size_t sum, const {{ class.bare_type }}Obj* obj) { return sum + obj->m_{{ member.name }}->size(); });
  m_vec_{{ member.name }}->reserve({{ member.name }}_size);
  int {{ member.name }}_index = 0;
{% endfor %}

{%- if OneToManyRelations or VectorMembers %}
  for (size_t i = 0, size = m_data->size(); i != size; ++i) {
{% for relation in OneToManyRelations %}
{{ macros.prepare_for_write_multi_relation(relation, loop.index0) }}
{% endfor %}
{% for member in VectorMembers %}
{{ macros.prepare_for_write_vector_member(member) }}
{% endfor %}
  }
{%- endif %}

{% for relation in OneToOneRelations %}
{{ macros.prepare_for_write_single_relation(relation, loop.index0, OneToManyRelations | length) }}
{% endfor %}
}

void {{ class_type }}::prepareAfterRead(uint32_t collectionID) {
  int index = 0;
  for (auto& data : *m_data) {
    auto obj = new {{ class.bare_type }}Obj({index, collectionID}, data);

{% for relation in OneToManyRelations %}
    obj->m_{{ relation.name }} = m_rel_{{ relation.name }}.get();
{% endfor %}
{% for member in VectorMembers %}
    obj->m_{{ member.name }} = m_vec_{{ member.name }}.get();
{% endfor %}
    entries.emplace_back(obj);
    ++index;
  }

  // at this point we could clear the I/O data buffer, but we keep them intact
  // because then we can save a call to prepareForWrite
}


{% if OneToManyRelations or VectorMembers %}
void {{ class_type }}::createRelations({{ class.bare_type }}Obj* obj) {
 {% for relation in OneToManyRelations %}
  // We take ownership of these here
  m_rel_{{ relation.name }}_tmp.emplace_back(obj->m_{{ relation.name }});
{% endfor %}
{% for member in VectorMembers %}
  // We take ownership of these here
  m_vecs_{{ member.name }}.emplace_back(obj->m_{{ member.name }});
{% endfor %}
}
{% endif %}

bool {{ class_type }}::setReferences(const podio::ICollectionProvider* collectionProvider, bool isSubsetColl) {
  if (isSubsetColl) {
    for (const auto& id : *m_refCollections[0]) {
{{ macros.get_obj_ptr(class.full_type) }}
      entries.push_back(obj);
    }
    return true; // TODO: check success, how?
  }

  // Normal collections have to resolve all relations
{% for relation in OneToManyRelations %}
{{ macros.set_references_multi_relation(relation, loop.index0) }}
{% endfor %}
{% for relation in OneToOneRelations %}
{{ macros.set_reference_single_relation(relation, loop.index0, OneToManyRelations | length) }}
{% endfor %}

  return true; // TODO: check success, how?
}

void {{ class_type }}::makeSubsetCollection() {
  // Subset collections do not need all the data buffers that normal
  // collections need, so we can free them here
  m_vecmem_info.clear();

  m_data.reset(nullptr);

{% for relation in OneToManyRelations + OneToOneRelations %}
  m_rel_{{ relation.name }}.reset(nullptr);
{% endfor %}
{% for member in VectorMembers %}
  m_vec_{{ member.name }}.reset(nullptr);
{% endfor %}

  // Subset collections need one vector of ObjectIDs for I/O purposes.
  m_refCollections.resize(1);
  m_refCollections[0] = std::make_unique<std::vector<podio::ObjectID>>();
}

{% endwith %}

{{ utils.namespace_close(class.namespace) }}