DataPointValue.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:   DataPointValue.h
 * Author: John Lång (john.larry.lang@cern.ch)
 *
 * Created on 23 September 2016, 12:20
 */
#ifndef O2_DCS_DATAPOINT_VALUE
#define O2_DCS_DATAPOINT_VALUE
 
#include <cstring>
#include <cstdint>
#include <ctime>
#include <atomic>
#include <string>
#include <ostream>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <memory>
#include <stdexcept>
#include "Rtypes.h"
#include "DetectorsDCS/StringUtils.h"
#include "DetectorsDCS/Clock.h"
#include "DetectorsDCS/DeliveryType.h"
 
namespace o2
{
namespace dcs
{
struct DataPointValue final {
  static constexpr uint16_t KEEP_ALIVE_FLAG = 0x0001;
 
  static constexpr uint16_t END_FLAG = 0x0002;
 
  static constexpr uint16_t FBI_FLAG = 0x0004;
 
  static constexpr uint16_t NEW_FLAG = 0x0008;
 
  static constexpr uint16_t DIRTY_FLAG = 0x0010;
 
  static constexpr uint64_t TURN_FLAG = 0x0020;
 
  static constexpr uint16_t WRITE_FLAG = 0x0040;
 
  static constexpr uint16_t READ_FLAG = 0x0080;
 
  static constexpr uint16_t OVERWRITE_FLAG = 0x0100;
 
  static constexpr uint16_t VICTIM_FLAG = 0x0200;
 
  static constexpr uint16_t DIM_ERROR_FLAG = 0x0400;
 
  static constexpr uint16_t BAD_DPID_FLAG = 0x0800;
 
  static constexpr uint16_t BAD_FLAGS_FLAG = 0x1000;
 
  static constexpr uint16_t BAD_TIMESTAMP_FLAG = 0x2000;
 
  static constexpr uint16_t BAD_PAYLOAD_FLAG = 0x4000;
 
  static constexpr uint16_t BAD_FBI_FLAG = 0x8000;
 
  static constexpr uint16_t SESSION_MASK = 0x0007;
 
  static constexpr uint16_t CONTROL_MASK = 0x00F8;
 
  static constexpr uint16_t ERROR_MASK = 0xFF00;
 
  uint16_t flags = 0;
 
  uint16_t msec = 0;
 
  uint32_t sec = 0;
 
  uint64_t payload_pt1 = 0;
 
  uint64_t payload_pt2 = 0;
 
  uint64_t payload_pt3 = 0;
 
  uint64_t payload_pt4 = 0;
 
  uint64_t payload_pt5 = 0;
 
  uint64_t payload_pt6 = 0;
 
  uint64_t payload_pt7 = 0;
 
  DataPointValue() = default;
 
  DataPointValue(const DataPointValue& other) = default;
 
  [[deprecated]] DataPointValue(
    const uint16_t flags,
    const uint16_t milliseconds,
    const uint32_t seconds,
    const uint64_t* const payload) noexcept : flags(flags), msec(milliseconds), sec(seconds)
  {
    memcpy((void*)&payload_pt1, (void*)payload, 56);
  }
 
  DataPointValue(
    const uint16_t flags,
    const uint16_t milliseconds,
    const uint32_t seconds,
    const uint64_t* const payload,
    const DeliveryType type)
    : flags(flags), msec(milliseconds), sec(seconds)
  {
    set_payload(payload, type);
  }
 
  inline void set_payload(
    const uint64_t* const data,
    const DeliveryType type)
  {
    switch (type) {
      case RAW_INT:
      case DPVAL_INT:
      case RAW_UINT:
      case DPVAL_UINT:
      case RAW_FLOAT:
      case DPVAL_FLOAT:
        this->payload_pt1 = data[0] & 0x00000000FFFFFFFF;
        break;
      case RAW_BOOL:
      case DPVAL_BOOL:
        this->payload_pt1 = (data[0] ? 1 : 0);
        break;
      case RAW_CHAR:
      case DPVAL_CHAR:
        this->payload_pt1 = data[0] & 0x00000000000000FF;
        break;
      case RAW_DOUBLE:
      case DPVAL_DOUBLE:
      case RAW_TIME:
      case DPVAL_TIME:
        this->payload_pt1 = data[0];
        break;
      case RAW_STRING:
      case DPVAL_STRING:
        std::strncpy((char*)&payload_pt1, (char*)data, 8);
        std::strncpy((char*)&payload_pt2, (char*)data + 8, 8);
        std::strncpy((char*)&payload_pt3, (char*)data + 16, 8);
        std::strncpy((char*)&payload_pt4, (char*)data + 24, 8);
        std::strncpy((char*)&payload_pt5, (char*)data + 32, 8);
        std::strncpy((char*)&payload_pt6, (char*)data + 40, 8);
        std::strncpy((char*)&payload_pt7, (char*)data + 48, 8);
        break;
      case RAW_BINARY:
      case DPVAL_BINARY:
        memcpy((void*)&payload_pt1, (void*)data, 56);
      case VOID:
        break;
      default:
        throw std::domain_error("Invalid DeliveryType.");
    }
  }
 
  inline uint16_t get_flags() const noexcept
  {
    return flags;
  }
 
  inline void update_timestamp() noexcept
  {
    const uint64_t current_time(o2::dcs::epoch_time());
    msec = current_time % 1000;
    sec = current_time / 1000;
  }
 
  inline std::unique_ptr<std::string> get_timestamp() const noexcept
  {
#if defined(__linux__) || defined(__APPLE__)
    // time_t should be uint64_t (compatible) on 64-bit Linux platforms:
    char buffer[33];
    std::time_t ts((uint64_t)sec);
    std::strftime(buffer, 32, "%FT%T", std::gmtime(&ts));
    std::ostringstream oss;
    oss << std::string(buffer) << "." << std::setw(3) << std::setfill('0') << std::to_string(msec) << "Z";
    return std::make_unique<std::string>(
      std::move(oss.str()));
#else
    return std::make_unique<std::string>("Unsupported platform");
#endif
  }
 
  inline uint64_t get_epoch_time() const noexcept
  {
    return (((uint64_t)sec) * 1000) + msec;
  }
 
  DataPointValue& operator=(const DataPointValue& other) = default;
 
  inline bool operator==(const DataPointValue& other) const noexcept
  {
    return memcmp((void*)this, (void*)&other, sizeof(DataPointValue)) == 0;
  }
 
  inline bool operator!=(const DataPointValue& other) const noexcept
  {
    return !(*this == other);
  }
 
  inline void set(
    const uint16_t flags,
    const uint16_t milliseconds,
    const uint32_t seconds,
    const uint64_t* const payload,
    const DeliveryType type)
  {
    this->flags = flags;
    this->msec = milliseconds;
    this->sec = seconds;
    set_payload(payload, type);
  }
 
  inline void set(
    const uint16_t milliseconds,
    const uint32_t seconds,
    const uint64_t* const payload,
    const DeliveryType type)
  {
    msec = milliseconds;
    sec = seconds;
    set_payload(payload, type);
  }
 
  inline void set(
    const uint64_t* const data,
    const DeliveryType type)
  {
    this->flags = data[0];
    this->msec = data[0] >> 16;
    this->sec = data[0] >> 32;
    set_payload(data + 1, type);
  }
 
  friend inline std::ostream& operator<<(std::ostream& os,
                                         const DataPointValue& dpval) noexcept
  {
    return os << ((dpval.flags & KEEP_ALIVE_FLAG) ? "A" : "-")
              << ((dpval.flags & END_FLAG) ? "Z" : "-")
              << ((dpval.flags & FBI_FLAG) ? "M" : "-")
              << ((dpval.flags & NEW_FLAG) ? "N" : "-")
              << ((dpval.flags & DIRTY_FLAG) ? "D" : "-")
              << ((dpval.flags & TURN_FLAG) ? "U" : "-")
              << ((dpval.flags & WRITE_FLAG) ? "W" : "-")
              << ((dpval.flags & READ_FLAG) ? "R " : "- ")
              << ((dpval.flags & OVERWRITE_FLAG) ? "O" : "-")
              << ((dpval.flags & VICTIM_FLAG) ? "V" : "-")
              << ((dpval.flags & DIM_ERROR_FLAG) ? "E" : "-")
              << ((dpval.flags & BAD_DPID_FLAG) ? "I" : "-")
              << ((dpval.flags & BAD_FLAGS_FLAG) ? "F" : "-")
              << ((dpval.flags & BAD_TIMESTAMP_FLAG) ? "T" : "-")
              << ((dpval.flags & BAD_PAYLOAD_FLAG) ? "P" : "-")
              << ((dpval.flags & BAD_FBI_FLAG) ? "B;" : "-;")
              << *(dpval.get_timestamp());
  }
 
  inline void acquire_write_lock()
  {
    flags |= WRITE_FLAG;
    flags |= TURN_FLAG;
    while (flags & READ_FLAG && flags & TURN_FLAG) {
    }
  }
 
  inline void release_write_lock()
  {
    flags &= ~WRITE_FLAG;
  }
 
  inline void acquire_read_lock()
  {
    flags |= READ_FLAG;
    flags &= ~TURN_FLAG;
    while (flags & WRITE_FLAG && !(flags & TURN_FLAG)) {
    }
  }
 
  inline void release_read_lock()
  {
    flags &= ~READ_FLAG;
  }
  ClassDefNV(DataPointValue, 1);
};
} // namespace dcs
} // namespace o2
 
#endif /* O2_DCS_DATAPOINT_VALUE_H */