Bouncer/src/xapp-formats/e2ap/subscription_helper.hpp

   1 /*
   2 ==================================================================================
   3         Copyright (c) 2018-2019 AT&T Intellectual Property.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 ==================================================================================
  17 */
  18
  19
  20 #ifndef SUB_HELPER_
  21 #define SUB_HELPER_
  22
  23 /*
  24    Simple structure to store action related information based on E2 v0.22
  25    Used for subscription request, response etc
  26
  27    ricActionID                                  RICactionID,
  28    ricActionType                                RICactionType,
  29    ricActionDefinition                  RICactionDefinition     OPTIONAL,
  30    ricSubsequentAction                  RICsubsequentAction     OPTIONAL,
  31    ricCause
  32 */
  33
  34 #include <iostream>
  35 #include <vector>
  36 #include <memory>
  37
  38 #include "generic_helpers.hpp"
  39
  40
  41 // Note : if no action definition specified, octet length of action definition  is NULL
  42 // If no subsequent action specified, default is subsequent_action = 0, time to wait is 0
  43 struct Action {
  44
  45 public:
  46
  47   Action(int id, int type): _is_def(false), _is_subs_act(false), _id(id), _type(type), _next_action(0), _wait(0){};
  48   Action(int id, int type, const void *def, size_t def_size, int next, int wait): _is_def(false), _is_subs_act(false), _id(id), _type(type){
  49
  50     if (def_size > 0){
  51       _is_def = true;
  52       _action_definition.set_ref(def);
  53       _action_definition.set_size(def_size);
  54     }
  55
  56     if(next >= 0 && wait >= 0){
  57       _is_subs_act = true;
  58       _next_action = next;
  59       _wait = wait;
  60     }
  61   };
  62
  63
  64   int get_id() const{
  65     return _id;
  66   }
  67
  68   int get_type() const {
  69     return _type;
  70   }
  71
  72
  73   const void * get_definition(void )  {
  74     return _action_definition.get_ref();
  75   }
  76
  77   int get_definition_size(void) const {
  78     return _action_definition.get_size();
  79   };
  80
  81
  82   int get_subsequent_action() const {
  83     return _next_action;
  84   };
  85
  86   int get_wait() const {
  87     return _wait;
  88   }
  89
  90   bool is_definition() const{
  91
  92     return _is_def;
  93   }
  94
  95   bool is_subsequent_action() const{
  96     return _is_subs_act;
  97   }
  98
  99 private:
 100
 101   bool _is_def;
 102   bool _is_subs_act;
 103   int _id, _type, _next_action, _wait, _cause, _sub_cause;
 104   bool _is_admit;
 105   octet_helper _action_definition;
 106
 107 };
 108
 109
 110 /*
 111  Helper class that stores subscription data
 112 */
 113
 114
 115 struct subscription_helper {
 116
 117 public:
 118
 119   using action_t = std::vector<Action>;
 120
 121   subscription_helper(){
 122     _action_ref = std::make_unique<action_t>();
 123     curr_index = 0;
 124   };
 125
 126   action_t * get_list() const {return _action_ref.get();};
 127
 128   void clear(void){
 129     _action_ref.get()->clear();
 130   }
 131
 132   void set_request(int id, int seq_no){
 133     _req_id = id;
 134     _req_seq_no = seq_no;
 135
 136   };
 137
 138   void set_function_id(int id){
 139     _func_id = id;
 140   };
 141
 142   void set_event_def(const void *ref, size_t size){
 143     _event_def.set_ref(ref);
 144     _event_def.set_size(size);
 145    };
 146
 147
 148   void add_action(int id, int type){
 149     Action a(id, type) ;
 150     _action_ref.get()->push_back(a);
 151   };
 152
 153   void add_action(int id, int type, std::string action_def, int next_action, int wait_time){
 154     Action a (id, type, action_def.c_str(), action_def.length(), next_action, wait_time);
 155     _action_ref.get()->push_back(a);
 156   };
 157
 158
 159   int  get_request_id(void) const{
 160     return _req_id;
 161   }
 162
 163   int  get_req_seq(void) const {
 164     return _req_seq_no;
 165   }
 166
 167   int  get_function_id(void) const{
 168     return _func_id;
 169   }
 170
 171   const void * get_event_def(void)  {
 172     return _event_def.get_ref();
 173   }
 174
 175   int get_event_def_size(void) const {
 176     return _event_def.get_size();
 177   }
 178
 179   void print_sub_info(void){
 180     std::cout <<"Request ID = " << _req_id << std::endl;
 181     std::cout <<"Request Sequence Number = " << _req_seq_no << std::endl;
 182     std::cout <<"RAN Function ID = " << _func_id << std::endl;
 183     for(auto const & e: *(_action_ref.get())){
 184       std::cout <<"Action ID = " << e.get_id() << " Action Type = " << e.get_type() << std::endl;
 185     }
 186   };
 187
 188 private:
 189
 190   std::unique_ptr<action_t> _action_ref;
 191   int curr_index;
 192   int _req_id, _req_seq_no, _func_id;
 193   octet_helper _event_def;
 194 };
 195
 196 #endif