NameHeader.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef NAMEHEADER_H
#define NAMEHEADER_H
 
#include <string>
#include "Headers/DataHeader.h"
 
namespace o2
{
namespace header
{
 
template <size_t N>
struct NameHeader : public BaseHeader {
  static const uint32_t sVersion;
  static const o2::header::HeaderType sHeaderType;
  static const o2::header::SerializationMethod sSerializationMethod;
  NameHeader() : BaseHeader(sizeof(NameHeader), sHeaderType, sSerializationMethod, sVersion), name()
  {
    static_assert(N > 0, "Can not construct zero-length NameHeader");
    // set length of padding in the last byte
    uint8_t* lastByte = reinterpret_cast<uint8_t*>(this) + sizeof(NameHeader) - 1;
    *lastByte =
      reinterpret_cast<const uint8_t*>(this) + sizeof(NameHeader) - reinterpret_cast<const uint8_t*>(&name[N]);
    // zero string
    memset(&name[0], '\0', N);
  }
 
  template <size_t S>
  NameHeader(const char (&in)[S]) : BaseHeader(sizeof(NameHeader), sHeaderType, sSerializationMethod, sVersion), name()
  {
    static_assert(N > 0, "Can not construct zero-length NameHeader");
    static_assert(S <= N, "Initializer string is exceeding NameHeader capacity");
    // set length of padding in the last byte
    uint8_t* lastByte = reinterpret_cast<uint8_t*>(this) + sizeof(NameHeader) - 1;
    *lastByte =
      reinterpret_cast<const uint8_t*>(this) + sizeof(NameHeader) - reinterpret_cast<const uint8_t*>(&name[N]);
    // here we actually want a null terminated string
    strncpy(name, in, N);
    name[N - 1] = '\0';
  }
 
  const char* getName() const { return name; }
  size_t getNameLength() const
  {
    // this only applies if the original buffer was created with N != 0
    // and this is now strictly required in the constructors
    const uint8_t* lastByte = reinterpret_cast<const uint8_t*>(this) + size() - 1;
    return (lastByte - reinterpret_cast<const uint8_t*>(name)) - *lastByte + 1;
  }
 
 private:
  char name[N];
};
 
template <size_t N>
const o2::header::HeaderType NameHeader<N>::sHeaderType = "NameHead";
 
// dirty trick to always have access to the headertypeID of a templated header type
// so when decoding an unknown length name use length 0
// TODO: find out if this can be done in a nicer way + is this realy necessary?
template <>
const o2::header::HeaderType NameHeader<0>::sHeaderType;
 
template <size_t N>
const SerializationMethod NameHeader<N>::sSerializationMethod = gSerializationMethodNone;
 
template <size_t N>
const uint32_t NameHeader<N>::sVersion = 1;
} // namespace header
} // namespace o2
 
#endif // NAMEHEADER_H