DataPointCompositeObject.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:   DataPointCompositeObject.h
 * Author: John Lång (john.larry.lang@cern.ch)
 *
 * Created on 23 September 2016, 11:28
 */
#ifndef O2_DCS_DATAPOINT_COMPOSITE_OBJECT_H
#define O2_DCS_DATAPOINT_COMPOSITE_OBJECT_H
 
#include <cstdint>
#include <stdexcept>
#include <ostream>
#include <string>
#include "Rtypes.h"
#include "DetectorsDCS/StringUtils.h"
#include "DetectorsDCS/DataPointIdentifier.h"
#include "DetectorsDCS/DataPointValue.h"
#include "DetectorsDCS/DeliveryType.h"
 
namespace o2
{
namespace dcs
{
struct DataPointCompositeObject final {
  const DataPointIdentifier id;
 
  DataPointValue data;
 
  DataPointCompositeObject() noexcept : id(), data() {}
 
  DataPointCompositeObject(
    const DataPointIdentifier& id,
    const DataPointValue& data) noexcept : id(id), data(data) {}
 
  DataPointCompositeObject(const DataPointCompositeObject& src) noexcept : DataPointCompositeObject(src.id, src.data) {}
 
  DataPointCompositeObject& operator=(const DataPointCompositeObject& src) noexcept
  {
    if (&src != this) {
      memcpy(this, &src, sizeof(DataPointCompositeObject));
    }
    return *this;
  }
 
  inline bool operator==(const DataPointCompositeObject& other) const
    noexcept
  {
    return id == other.id && data == other.data;
  }
 
  inline bool operator!=(const DataPointCompositeObject& other) const
    noexcept
  {
    return id != other.id || data != other.data;
  }
 
  inline void set(const DataPointIdentifier& id, DataPointValue& data) noexcept
  {
    DataPointIdentifier::FILL(this->id, (uint64_t*)&id);
    this->data = data;
  }
 
  inline void set(const uint64_t* const data) noexcept
  {
    DataPointIdentifier::FILL(this->id, data);
    this->data.set(data + 8, id.get_type());
  }
 
  inline void update(const DataPointValue& dpval) noexcept
  {
    data.set(
      dpval.flags & ~DataPointValue::CONTROL_MASK,
      dpval.msec,
      dpval.sec,
      (uint64_t*)&dpval.payload_pt1,
      id.get_type());
  }
 
  inline void* dim_buffer() const
  {
    switch (id.get_type()) {
      case RAW_INT:
      case RAW_UINT:
      case RAW_BOOL:
      case RAW_CHAR:
      case RAW_DOUBLE:
      case RAW_TIME:
      case RAW_STRING:
      case RAW_BINARY:
      case RAW_FLOAT:
        return (void*)&data.payload_pt1;
      case DPVAL_INT:
      case DPVAL_UINT:
      case DPVAL_BOOL:
      case DPVAL_CHAR:
      case DPVAL_DOUBLE:
      case DPVAL_TIME:
      case DPVAL_STRING:
      case DPVAL_BINARY:
      case DPVAL_FLOAT:
        return (void*)&data;
      default:
      case VOID:
        throw std::domain_error("Illegal DeliveryType.");
    }
  }
 
  inline friend std::ostream& operator<<(std::ostream& os,
                                         const DataPointCompositeObject& dpcom) noexcept
  {
    std::string payload;
    os << dpcom.id << ";" << dpcom.data << ";";
    union Converter {
      uint64_t raw_data;
      float float_value;
      double double_value;
      uint32_t uint_value;
      int32_t int_value;
      char char_value;
      bool bool_value;
    } converter;
    converter.raw_data = dpcom.data.payload_pt1;
    switch (dpcom.id.get_type()) {
      case VOID:
        return os;
      case RAW_INT:
      case DPVAL_INT:
        return os << converter.int_value;
      case RAW_UINT:
      case DPVAL_UINT:
        return os << converter.uint_value;
      case RAW_BOOL:
      case DPVAL_BOOL:
        return os << (converter.bool_value ? "True" : "False");
      case RAW_CHAR:
      case DPVAL_CHAR:
        return os << converter.char_value;
      case RAW_FLOAT:
      case DPVAL_FLOAT:
        return os << converter.float_value;
      case RAW_DOUBLE:
      case DPVAL_DOUBLE:
        return os << converter.double_value;
      case RAW_STRING:
      case DPVAL_STRING:
        return os << std::string((char*)&dpcom.data.payload_pt1);
      case RAW_TIME:
      case DPVAL_TIME: {
        // I have no idea how to properly test the time_t backend.
        // It's probably even hardware/os/kernel specific...
#ifdef __linux__
        char buffer[17];
        std::time_t ts((dpcom.data.payload_pt1) >> 32);
        std::strftime(buffer, 32, "%FT%T", std::gmtime(&ts));
        return os << std::string(buffer) << "." << std::setw(3) << std::setfill('0') << std::to_string((dpcom.data.payload_pt1 & 0x00000000FFFF0000) >> 16)
                  << "Z";
#else
        return os << "[Timestamps not supported on this platform.]";
#endif
      }
      case RAW_BINARY:
      case DPVAL_BINARY:
      default:
        return os << o2::dcs::to_hex_little_endian(
                 (char*)&dpcom.data.payload_pt1, 56);
    }
  }
 
  ~DataPointCompositeObject() noexcept = default;
  ClassDefNV(DataPointCompositeObject, 1);
};
 
template <typename T>
T getValue(const DataPointCompositeObject& dpcom);
 
} // namespace dcs
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::dcs::DataPointCompositeObject> : std::true_type {
};
} // namespace framework
 
} // namespace o2
 
namespace std
{
template <>
struct is_trivially_copyable<o2::dcs::DataPointCompositeObject> : std::true_type {
};
} // namespace std
 
#endif /* O2_DCS_DATAPOINT_COMPOSITE_OBJECT_H */