SIOBlock.cc.jinja2

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

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

#include "podio/CollectionBuffers.h"

#include <sio/block.h>
#include <sio/io_device.h>
#include <sio/version.h>

{{ utils.namespace_open(class.namespace) }}
{% with block_class = class.bare_type + 'SIOBlock' %}

void {{ block_class }}::read(sio::read_device& device, sio::version_type) {
  if (m_subsetColl) {
    m_buffers.references->emplace_back(std::make_unique<std::vector<podio::ObjectID>>());
  } else {
{% for relation in OneToManyRelations + OneToOneRelations %}
    m_buffers.references->emplace_back(std::make_unique<std::vector<podio::ObjectID>>());
{% endfor %}
  }

  if (not m_subsetColl) {
    unsigned size(0);
    device.data( size );
    m_buffers.data = new std::vector<{{ class.full_type }}Data>(size);
    auto* dataVec = m_buffers.dataAsVector<{{ class.full_type }}Data>();
    podio::handlePODDataSIO(device, dataVec->data(), size);
    // m_buffers.data = dataVec;
  }

  //---- read ref collections -----
  auto* refCols = m_buffers.references;
  for( auto& refC : *refCols ){
    unsigned size{0};
    device.data( size ) ;
    refC->resize(size) ;
    podio::handlePODDataSIO( device ,  refC->data(), size ) ;
  }

{% if VectorMembers %}
{% for member in VectorMembers %}
  // auto {{ member.name }}Buffers = new std::vector<{{ member.full_type }}>();
  // m_buffers.vectorMembers->emplace_back("{{ member.full_type }}", &{{ member.name }}Buffers);
  m_buffers.vectorMembers->emplace_back("{{ member.full_type }}", new std::vector<{{ member.full_type }}>());
{% endfor %}
  //---- read vector members
  auto* vecMemInfo = m_buffers.vectorMembers;
  unsigned size{0};

{% for member in VectorMembers %}
{{ macros.vector_member_read(member, loop.index0) }}
{% endfor %}
{% endif %}
}

void {{ block_class }}::write(sio::write_device& device) {
  if (not m_subsetColl) {
    auto* dataVec = podio::CollectionWriteBuffers::asVector<{{ class.full_type }}Data>(m_buffers.data);
    unsigned size = dataVec->size() ;
    device.data( size ) ;
    podio::handlePODDataSIO( device ,  dataVec->data(), size ) ;
  }

  //---- write ref collections -----
  auto* refCols = m_buffers.references;
  for( auto& refC : *refCols ){
    unsigned size = refC->size() ;
    device.data( size ) ;
    podio::handlePODDataSIO( device ,  refC->data(), size ) ;
  }

{% if VectorMembers %}
  //---- write vector members
  auto* vecMemInfo = m_buffers.vectorMembers;
  unsigned size{0};

{% for member in VectorMembers %}
{{ macros.vector_member_write(member, loop.index0) }}
{% endfor %}
{% endif %}
}

void {{ block_class }}::createBuffers(bool subsetColl) {
  m_subsetColl = subsetColl;



  m_buffers.references = new podio::CollRefCollection();
  m_buffers.vectorMembers = new podio::VectorMembersInfo();

  m_buffers.createCollection = [](podio::CollectionReadBuffers buffers, bool isSubsetColl) {
    {{ class.bare_type }}CollectionData data(buffers, isSubsetColl);
    return std::make_unique<{{ class.bare_type }}Collection>(std::move(data), isSubsetColl);
  };
}

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