DeliveryType.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:   DeliveryType.h
 * Author: John Lång (john.larry.lang@cern.ch)
 *
 * Created on 17 July 2015, 9:54
 */
 
#ifndef O2_DCS_DELIVERY_TYPE
#define O2_DCS_DELIVERY_TYPE
 
#include <string>
#include <bitset>
#include <stdexcept>
#include "DetectorsDCS/GenericFunctions.h"
 
namespace o2::dcs
{
enum DeliveryType {
  VOID = 0,
 
  RAW_BINARY = 64,
 
  DPVAL_BINARY = 192,
 
  RAW_INT = 21,
 
  DPVAL_INT = 149,
 
  RAW_UINT = 20,
 
  DPVAL_UINT = 148,
 
  RAW_DOUBLE = 22,
 
  DPVAL_DOUBLE = 150,
 
  RAW_FLOAT = 28,
 
  DPVAL_FLOAT = 156,
 
  RAW_BOOL = 23,
 
  DPVAL_BOOL = 151,
 
  RAW_CHAR = 19,
 
  DPVAL_CHAR = 147,
 
  RAW_STRING = 25,
 
  DPVAL_STRING = 153,
 
  RAW_TIME = 4,
 
  DPVAL_TIME = 132
};
 
template <>
inline DeliveryType read(const std::string& str)
{
  if (str == "Raw/Int") {
    return RAW_INT;
  } else if (str == "Raw/Uint") {
    return RAW_UINT;
  } else if (str == "Raw/Float") {
    return RAW_FLOAT;
  } else if (str == "Raw/Double") {
    return RAW_DOUBLE;
  } else if (str == "Raw/Bool") {
    return RAW_BOOL;
  } else if (str == "Raw/Char") {
    return RAW_CHAR;
  } else if (str == "Raw/String") {
    return RAW_STRING;
  } else if (str == "Raw/Binary") {
    return RAW_BINARY;
  } else if (str == "Raw/Time") {
    return RAW_TIME;
  } else if (str == "DPVAL/Int") {
    return DPVAL_INT;
  } else if (str == "DPVAL/Uint") {
    return DPVAL_UINT;
  } else if (str == "DPVAL/Float") {
    return DPVAL_FLOAT;
  } else if (str == "DPVAL/Double") {
    return DPVAL_DOUBLE;
  } else if (str == "DPVAL/Bool") {
    return DPVAL_BOOL;
  } else if (str == "DPVAL/Char") {
    return DPVAL_CHAR;
  } else if (str == "DPVAL/String") {
    return DPVAL_STRING;
  } else if (str == "DPVAL/Binary") {
    return DPVAL_BINARY;
  } else if (str == "DPVAL/Time") {
    return DPVAL_TIME;
  } else if (str == "Void") {
    return VOID;
  } else {
    throw std::domain_error("\"" + str +
                            "\" doesn't represent a DeliveryType.");
  }
}
 
template <>
inline std::string show(const DeliveryType type)
{
  switch (type) {
    case RAW_INT:
      return "Raw/Int";
    case RAW_UINT:
      return "Raw/Uint";
    case RAW_BOOL:
      return "Raw/Bool";
    case RAW_CHAR:
      return "Raw/Char";
    case RAW_FLOAT:
      return "Raw/Float";
    case RAW_DOUBLE:
      return "Raw/Double";
    case RAW_TIME:
      return "Raw/Time";
    case RAW_STRING:
      return "Raw/String";
    case RAW_BINARY:
      return "Raw/Binary";
    case DPVAL_INT:
      return "DPVAL/Int";
    case DPVAL_UINT:
      return "DPVAL/Uint";
    case DPVAL_BOOL:
      return "DPVAL/Bool";
    case DPVAL_CHAR:
      return "DPVAL/Char";
    case DPVAL_FLOAT:
      return "DPVAL/Float";
    case DPVAL_DOUBLE:
      return "DPVAL/Double";
    case DPVAL_TIME:
      return "DPVAL/Time";
    case DPVAL_STRING:
      return "DPVAL/String";
    case DPVAL_BINARY:
      return "DPVAL/Binary";
    case VOID:
      return "Void";
    default:
      throw std::domain_error("Illegal DeliveryType.");
  }
}
 
inline bool DPVAL_variant(const DeliveryType type)
{
  switch (type) {
    case DPVAL_INT:
    case DPVAL_UINT:
    case DPVAL_BOOL:
    case DPVAL_CHAR:
    case DPVAL_FLOAT:
    case DPVAL_DOUBLE:
    case DPVAL_TIME:
    case DPVAL_STRING:
    case DPVAL_BINARY:
      return true;
    case RAW_INT:
    case RAW_UINT:
    case RAW_BOOL:
    case RAW_CHAR:
    case RAW_FLOAT:
    case RAW_DOUBLE:
    case RAW_TIME:
    case RAW_STRING:
    case RAW_BINARY:
    case VOID:
      return false;
    default:
      throw std::domain_error("Illegal DeliveryType.");
  }
}
 
inline std::string dim_description(const DeliveryType type)
{
 
  switch (type) {
    case RAW_INT:
      return "I:1";
    case RAW_UINT:
      return "I:1";
    case RAW_BOOL:
      return "I:1";
    case RAW_CHAR:
      return "C:4";
    case RAW_FLOAT:
      return "F:1";
    case RAW_DOUBLE:
      return "D:1";
    case RAW_TIME:
      return "I:2";
    case RAW_STRING:
      return "C:55";
    case RAW_BINARY:
      return "C:56";
    case DPVAL_INT:
      return "S:2;I:1;I:1";
    case DPVAL_UINT:
      return "S:2;I:1;I:1";
    case DPVAL_BOOL:
      return "S:2;I:1;I:1";
    case DPVAL_CHAR:
      return "S:2;I:1;C:4";
    case DPVAL_FLOAT:
      return "S:2;I:1;F:1";
    case DPVAL_DOUBLE:
      return "S:2;I:1;D:1";
    case DPVAL_TIME:
      return "S:2;I:1;I:2";
    case DPVAL_STRING:
      return "S:2;I:1;C:55";
    case DPVAL_BINARY:
      return "S:2;I:1;C:56";
    case VOID:
    default:
      throw std::domain_error("Illegal DeliveryType.");
  }
}
 
inline size_t dim_buffer_size(const DeliveryType type)
{
  switch (type) {
    case RAW_INT:
    case RAW_UINT:
    case RAW_BOOL:
    case RAW_CHAR:
    case RAW_FLOAT:
      return 4;
    case RAW_DOUBLE:
    case RAW_TIME:
      return 8;
    case RAW_STRING:
      return 55;
    case RAW_BINARY:
      return 56;
    case DPVAL_INT:
    case DPVAL_UINT:
    case DPVAL_BOOL:
    case DPVAL_CHAR:
    case DPVAL_FLOAT:
    case DPVAL_DOUBLE:
    case DPVAL_TIME:
    case DPVAL_STRING:
    case DPVAL_BINARY:
      return 64;
    case VOID:
      return 0;
    default:
      throw std::domain_error("Illegal DeliveryType.");
  }
}
} // namespace o2::dcs
 
 
 
#endif /* O2_DCS_DELIVERY_TYPE */