implementations.jinja2

{% macro constructors_destructors(type, members, one_to_one_relations=[], multi_relations=[], prefix='') %}
{% set full_type = prefix + type %}

{{ full_type }}::{{ full_type }}() :
  m_obj(new {{ type }}Obj{}, podio::utils::MarkOwned) {}

{% if members %}
{{ full_type }}::{{ full_type }}({{ members | map(attribute='signature') | join(', ') }}) :
  m_obj(new {{ type }}Obj{}, podio::utils::MarkOwned) {
{% for member in members %}
  m_obj->data.{{ member.name }} = {{ member.name }};
{% endfor %}
}
{% endif %}

{{  full_type }}& {{ full_type }}::operator=({{ full_type }} other) {
  swap(*this, other);
  return *this;
}

Mutable{{ type }} {{ full_type }}::clone(bool cloneRelations) const {
{% if prefix %}
  if (!cloneRelations) {
    auto tmp = new {{ type }}Obj(podio::ObjectID{}, m_obj->data);
{% for relation in multi_relations %}
    tmp->m_{{ relation.name }} = new std::vector<{{ relation.full_type }}>();
    tmp->data.{{ relation.name }}_begin = 0;
    tmp->data.{{ relation.name }}_end = 0;
{% endfor %}
    return Mutable{{ type }}(podio::utils::MaybeSharedPtr(tmp, podio::utils::MarkOwned));
  }
  return Mutable{{ type }}(podio::utils::MaybeSharedPtr(new {{ type }}Obj(*m_obj), podio::utils::MarkOwned));
{% else %}
  auto tmp = new {{ type }}Obj(podio::ObjectID{}, m_obj->data);
{% for relation in multi_relations %}
  tmp->m_{{ relation.name }} = new std::vector<{{ relation.full_type }}>();
{% endfor %}
  if (cloneRelations) {
{% for relation in one_to_one_relations %}
  if (m_obj->m_{{ relation.name }}) {
    tmp->m_{{ relation.name }} = new {{ relation.full_type }}(*m_obj->m_{{ relation.name }});
  }
{% endfor %}
{% for relation in multi_relations %}
    // If the current object has been read from a file, then the object may only have a slice of the relation vector
    // so this slice has to be copied in case we want to modify it
    tmp->m_{{ relation.name }}->reserve(m_obj->m_{{ relation.name }}->size());
    for (size_t i = m_obj->data.{{ relation.name }}_begin; i < m_obj->data.{{ relation.name }}_end; i++) {
      tmp->m_{{ relation.name }}->emplace_back((*m_obj->m_{{ relation.name }})[i]);
    }
    tmp->data.{{ relation.name }}_begin = 0;
    tmp->data.{{ relation.name }}_end = tmp->m_{{ relation.name }}->size();
{% endfor %}
  }
  else {
{% for relation in multi_relations %}
    tmp->data.{{ relation.name }}_begin = 0;
    tmp->data.{{ relation.name }}_end = 0;
{% endfor %}
  }
  return Mutable{{ type }}(podio::utils::MaybeSharedPtr(tmp, podio::utils::MarkOwned));
{% endif %}
}

{{ full_type }}::{{ full_type }}(podio::utils::MaybeSharedPtr<{{ type }}Obj> obj) : m_obj(std::move(obj)) {}

{%- endmacro %}


{% macro member_getters(class, members, get_syntax, prefix='') %}
{% set class_type = prefix + class.bare_type %}
{% for member in members %}
{{ member.getter_return_type() }} {{ class_type }}::{{ member.getter_name(get_syntax) }}() const { return m_obj->data.{{ member.name }}; }
{% if member.is_array %}
{{ member.getter_return_type(True) }} {{ class_type }}::{{ member.getter_name(get_syntax) }}(size_t i) const { return m_obj->data.{{ member.name }}.at(i); }
{% endif %}
{% if member.sub_members %}
{% for sub_member in member.sub_members %}
{{ sub_member.getter_return_type() }} {{ class_type }}::{{ sub_member.getter_name(get_syntax) }}() const { return m_obj->data.{{ member.name }}.{{ sub_member.name }}; }
{% endfor %}
{%- endif %}
{% endfor %}
{%- endmacro %}


{% macro member_setters(class, members, get_syntax, prefix='') %}
{% set class_type = prefix + class.bare_type %}
{% for member in members %}
void {{ class_type }}::{{ member.setter_name(get_syntax) }}({{ member.full_type }} value) { m_obj->data.{{ member.name }} = value; }
{% if member.is_array %}
void {{ class_type }}::{{ member.setter_name(get_syntax) }}(size_t i, {{ member.array_type }} value) { m_obj->data.{{ member.name }}.at(i) = value; }
{% endif %}
{{ member.full_type }}& {{ class_type }}::{{ member.getter_name(get_syntax) }}() { return m_obj->data.{{ member.name }}; }
{% if get_syntax %}
{{ member.full_type }}& {{ class_type }}::{{ member.name }}() {  return m_obj->data.{{ member.name }}; }
{% endif %}
{% if member.sub_members %}
{% for sub_member in member.sub_members %}
void {{ class_type }}::{{ sub_member.setter_name(get_syntax) }}({{ sub_member.full_type }} value) { m_obj->data.{{ member.name }}.{{ sub_member.name }} = value; }
{% if not sub_member.is_builtin %}
{{ sub_member.full_type }}& {{ class_type }}::{{ sub_member.name }}() { return m_obj->data.{{ member.name }}.{{ sub_member.name }}; }
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
{%- endmacro %}


{% macro single_relation_getters(class, relations, get_syntax, prefix='') %}
{% set class_type = prefix + class.bare_type %}
{% for relation in relations %}
const {{ relation.full_type }} {{ class_type }}::{{ relation.getter_name(get_syntax) }}() const {
  if (!m_obj->m_{{ relation.name }}) {
    return {{ relation.full_type }}::makeEmpty();
  }
  return {{ relation.full_type }}(*(m_obj->m_{{ relation.name }}));
}

{% endfor %}
{%- endmacro %}


{% macro single_relation_setters(class, relations, get_syntax, prefix='') %}
{% set class_type = prefix + class.bare_type %}
{% for relation in relations %}
void {{ class_type }}::{{ relation.setter_name(get_syntax) }}({{ relation.full_type }} value) {
  if (m_obj->m_{{ relation.name }}) {
    delete m_obj->m_{{ relation.name }};
  }
  m_obj->m_{{ relation.name }} = new {{ relation.full_type }}(value);
}

{% endfor %}
{%- endmacro %}


{% macro multi_relation_handling(class, relations, get_syntax, prefix='', with_adder=False) %}
{% set class_type = prefix + class.bare_type %}
{% for relation in relations %}
{% if with_adder %}
void {{ class_type }}::{{ relation.setter_name(get_syntax, is_relation=True) }}(const {{ relation.full_type }}& component) {
  m_obj->m_{{ relation.name }}->push_back(component);
  m_obj->data.{{ relation.name }}_end++;
}
{% endif %}

std::vector<{{ relation.full_type }}>::const_iterator {{ class_type }}::{{ relation.name }}_begin() const {
  auto ret_value = m_obj->m_{{ relation.name }}->begin();
  std::advance(ret_value, m_obj->data.{{ relation.name }}_begin);
  return ret_value;
}

std::vector<{{ relation.full_type }}>::const_iterator {{ class_type }}::{{ relation.name }}_end() const {
  auto ret_value = m_obj->m_{{ relation.name }}->begin();
  std::advance(ret_value, m_obj->data.{{ relation.name }}_end);
  return ret_value;
}

std::size_t {{ class_type }}::{{ relation.name }}_size() const {
  return m_obj->data.{{ relation.name }}_end - m_obj->data.{{ relation.name }}_begin;
}

{{ relation.full_type }} {{ class_type }}::{{ relation.getter_name(get_syntax) }}(std::size_t index) const {
  if ({{ relation.name }}_size() > index) {
    return m_obj->m_{{ relation.name }}->at(m_obj->data.{{ relation.name }}_begin + index);
  }
  throw std::out_of_range("index out of bounds for existing references");
}

podio::RelationRange<{{ relation.full_type }}> {{ class_type }}::{{ relation.getter_name(get_syntax) }}() const {
  auto begin = m_obj->m_{{ relation.name }}->begin();
  std::advance(begin, m_obj->data.{{ relation.name }}_begin);
  auto end = m_obj->m_{{ relation.name }}->begin();
  std::advance(end, m_obj->data.{{ relation.name }}_end);
  return {begin, end};
}

{% endfor %}
{% endmacro %}


{% macro common_object_funcs(class, prefix='') %}
{% set full_type = prefix + class.bare_type %}
bool {{ full_type }}::isAvailable() const {
  if (m_obj) {
    return true;
  }
  return false;
}

const podio::ObjectID {{ full_type }}::getObjectID() const {
  if (m_obj) {
    return m_obj->id;
  }
  return podio::ObjectID{};
}

{% set inverse_type = class.bare_type if prefix else 'Mutable' + class.bare_type %}
bool {{ full_type }}::operator==(const {{ inverse_type }}& other) const {
  return m_obj == other.m_obj;
}
{%- endmacro %}


{% macro ostream_operator(type, members, single_relations, multi_relations, get_syntax) %}
std::ostream& operator<<(std::ostream& o, const {{ type }}& value) {
  if (!value.isAvailable()) {
    return o << "[not available]";
  }
  o << " id: " << value.id() << '\n';
{% for member in members %}
{% if member.is_array %}
  o << " {{ member.name }} : ";
  for (size_t i = 0; i < {{ member.array_size }}; ++i) {
    o << value.{{ member.getter_name(get_syntax) }}()[i] << "|";
  }
  o << '\n';
{% else %}
  o << " {{ member.name }} : " << value.{{ member.getter_name(get_syntax) }}() << '\n';
{% endif %}
{% endfor %}

{% for relation in single_relations %}
  o << " {{ relation.name }} : " << value.{{ relation.getter_name(get_syntax) }}().id() << '\n';
{% endfor %}

{% for relation in multi_relations %}
  o << " {{ relation.name }} : ";
  for (unsigned i = 0; i < value.{{ relation.name }}_size(); ++i) {
{% if type == relation.bare_type %}
    o << value.{{ relation.getter_name(get_syntax) }}(i).id() << " ";
{% else %}
    o << value.{{ relation.getter_name(get_syntax) }}(i) << " ";
{% endif %}
  }
  o << '\n';
{% endfor %}

  return o;
}
{%- endmacro %}

{% macro json_output(class, members, single_relations, multi_relations, vector_members, get_syntax, prefix='') %}
#if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
void to_json(nlohmann::json& j, const {{ prefix }}{{ class.bare_type }}& value) {
  j = nlohmann::json{
{% set comma = joiner(",") %}
{% for member in members %}
    {{ comma() }}{"{{ member.name }}", value.{{ member.getter_name(get_syntax)}}()}
{% endfor %}
{% for member in vector_members %}
    {{ comma() }}{"{{ member.name }}", value.{{ member.getter_name(get_syntax) }}()}
{% endfor %}
  };

{% for relation in single_relations %}
    j["{{ relation.name }}"] = nlohmann::json{
      {"collectionID", value.{{ relation.getter_name(get_syntax) }}().getObjectID().collectionID },
      {"index", value.{{ relation.getter_name(get_syntax) }}().getObjectID().index }};

{% endfor %}

{% for relation in multi_relations %}
  j["{{ relation.name }}"] = nlohmann::json::array();
  for (const auto& v : value.{{ relation.getter_name(get_syntax) }}()) {
    j["{{ relation.name }}"].emplace_back(nlohmann::json{
      {"collectionID", v.getObjectID().collectionID },
      {"index", v.getObjectID().index }});
  }

{% endfor %}
}
#endif
{% endmacro %}