Schema.hpp

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS config source for the DUNE DAQ project.
// Fork baseline commit: 67a24e731 (2022-10-27).
// Renamed since fork: yes (from config/Schema.h to include/conffwk/Schema.hpp).
//

 
#ifndef CONFFWK_SCHEMA_H_
#define CONFFWK_SCHEMA_H_
 
#include <string>
#include <vector>
#include <iostream>
 
namespace dunedaq {
  namespace conffwk {

 
    enum type_t {
      bool_type,       
      s8_type,         
      u8_type,         
      s16_type,        
      u16_type,        
      s32_type,        
      u32_type,        
      s64_type,        
      u64_type,        
      float_type,      
      double_type,     
      date_type,       
      time_type,       
      string_type,     
      enum_type,       
      class_type       
    };
 

 
    enum int_format_t {
      oct_int_format,  
      dec_int_format,  
      hex_int_format,  
      na_int_format    
    };
 

 
    struct attribute_t {
 
      std::string p_name;            
      type_t p_type;                 
      std::string p_range;           
      int_format_t p_int_format;     
      bool p_is_not_null;            
      bool p_is_multi_value;         
      std::string p_default_value;   
      std::string p_description;     

 
      attribute_t(
        const std::string& name,
        type_t type,
        const std::string& range,
        int_format_t int_format,
        bool is_not_null,
        bool is_multi_value,
        const std::string& default_value,
        const std::string& description
      );
 

 
      attribute_t() { ; }
 

 
      void print(
        std::ostream& out,               
        const std::string& prefix = ""   
      ) const;

      static const char * type2str(type_t type );

      static const char * type(type_t type );

      static const char * format2str(int_format_t format );
 
    };
 

 
    enum cardinality_t {
      zero_or_one,    
      zero_or_many,   
      only_one,       
      one_or_many     
    };
 

 
    struct relationship_t {
 
      std::string p_name;           
      std::string p_type;           
      cardinality_t p_cardinality;  
      bool p_is_aggregation;        
      std::string p_description;    

 
      relationship_t(
        const std::string& name,
        const std::string& type,
        bool can_be_null,
        bool is_multi_value,
        bool is_aggregation,
        const std::string& description
      );
 

 
      relationship_t() { ; }
 

 
      void print(
        std::ostream& out,               
        const std::string& prefix = ""   
      ) const;
 

 
      static const char * card2str(cardinality_t cardinality);
 
    };
 

 
    struct class_t {
 
      std::string p_name;                                  
      std::string p_description;                           
      std::string p_schema_path;                           
      bool p_abstract;                                     
      const std::vector<std::string> p_superclasses;       
      const std::vector<std::string> p_subclasses;         
      const std::vector<attribute_t> p_attributes;         
      const std::vector<relationship_t> p_relationships;   

 
      class_t(
        const std::string& name,
        const std::string& description,
        const std::string& schema_path,
        bool is_abstract
      );
 

 
      class_t() { ; }
 

 
      void print(
        std::ostream& out,               
        const std::string& prefix = ""   
      ) const;
 
    };
 
    const char * bool2str(bool value);
 
    std::ostream& operator<<(std::ostream& out, const attribute_t &);
    std::ostream& operator<<(std::ostream& out, const relationship_t &);
    std::ostream& operator<<(std::ostream& out, const class_t &);
 
  }
}
 
#endif // CONFFWK_SCHEMA_H_