DataPointIdentifier.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.
 
/*
 * File:   DataPointIdentifier.h
 * Author: John Lång (john.larry.lang@cern.ch)
 *
 * Created on 23 September 2016, 12:00
 */
#ifndef O2_DCS_DATAPOINT_IDENTIFIER_H
#define O2_DCS_DATAPOINT_IDENTIFIER_H
 
#include <cstring>
#include <string>
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <functional>
#include <unordered_map>
 
#include "Rtypes.h"
#include "DetectorsDCS/StringUtils.h"
#include "DetectorsDCS/GenericFunctions.h"
#include "DetectorsDCS/DeliveryType.h"
 
namespace o2
{
namespace dcs
{
class DataPointIdentifier final
{
  const uint64_t pt1;
  const uint64_t pt2;
  const uint64_t pt3;
  const uint64_t pt4;
  const uint64_t pt5;
  const uint64_t pt6;
  const uint64_t pt7;
  const uint64_t pt8; // Contains the last 6 chars of alias and the type.
 
  DataPointIdentifier(
    const uint64_t pt1, const uint64_t pt2, const uint64_t pt3,
    const uint64_t pt4, const uint64_t pt5, const uint64_t pt6,
    const uint64_t pt7, const uint64_t pt8) noexcept : pt1(pt1), pt2(pt2), pt3(pt3), pt4(pt4), pt5(pt5), pt6(pt6), pt7(pt7), pt8(pt8) {}
 
 public:
  DataPointIdentifier() noexcept : pt1(0), pt2(0), pt3(0), pt4(0), pt5(0), pt6(0), pt7(0), pt8(0)
  {
  }
 
  DataPointIdentifier(const std::string& alias, const DeliveryType type) noexcept : DataPointIdentifier()
  {
    strncpy((char*)this, alias.c_str(), 62);
    ((char*)&pt8)[7] = type;
  }
 
  DataPointIdentifier(const DataPointIdentifier& src) noexcept : DataPointIdentifier(src.pt1, src.pt2, src.pt3, src.pt4, src.pt5, src.pt6, src.pt7, src.pt8) {}
 
  DataPointIdentifier& operator=(const DataPointIdentifier& src) noexcept
  {
    if (&src != this) {
      memcpy(this, &src, sizeof(DataPointIdentifier));
    }
    return *this;
  }
 
  static inline void FILL(
    const DataPointIdentifier& dpid,
    const std::string& alias,
    const DeliveryType type) noexcept
  {
    strncpy((char*)&dpid, alias.c_str(), 62);
    ((char*)&dpid.pt8)[7] = type;
  }
 
  static inline void FILL(
    const DataPointIdentifier& dpid,
    const uint64_t* const data) noexcept
  {
    std::strncpy((char*)&dpid, (char*)data, 62);
    ((char*)&dpid)[63] = ((data[7] & 0xFF00000000000000) >> 56);
  }
 
  inline bool operator==(const DataPointIdentifier& other) const
  {
    constexpr char mask = 0x7F;
 
    return (memcmp((char*)this, (char*)&other, 63) == 0) &&
           (((DeliveryType)this->get_type() & mask) == ((DeliveryType)other.get_type() & mask));
  }
 
  inline bool operator!=(const DataPointIdentifier& other) const
  {
    return !(*this == other);
  }
 
  friend inline std::ostream& operator<<(std::ostream& os,
                                         const DataPointIdentifier& dpid) noexcept
  {
    return os << std::string((char*)&dpid) << ";" << o2::dcs::show((DeliveryType)((dpid.pt8 & 0xFF00000000000000) >> 56));
  }
 
  inline const char* const get_alias() const noexcept
  {
    return (char*)&pt1;
  }
 
  inline DeliveryType get_type() const noexcept
  {
    return (DeliveryType)((pt8 & 0xFF00000000000000) >> 56);
  }
 
  inline size_t hash_code() const noexcept
  {
    return o2::dcs::hash_code(std::string((char*)&pt1));
  }
 
  ~DataPointIdentifier() noexcept = default;
  ClassDefNV(DataPointIdentifier, 1);
};
 
struct DPIDHash {
  uint64_t operator()(const o2::dcs::DataPointIdentifier& dpid)
    const
  {
    return dpid.hash_code();
  }
};
} // namespace dcs
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::dcs::DataPointIdentifier> : std::true_type {
};
} // namespace framework
 
} // namespace o2
 
// specailized std::hash
namespace std
{
template <>
struct hash<o2::dcs::DataPointIdentifier> {
  std::size_t operator()(const o2::dcs::DataPointIdentifier& dpid) const
  {
    return std::hash<uint64_t>{}(dpid.hash_code());
  }
};
 
template <>
struct is_trivially_copyable<o2::dcs::DataPointIdentifier> : std::true_type {
};
 
} // namespace std
 
#endif /* O2_DCS_DATAPOINT_IDENTIFIER_H */