lib/component/iterator.c

   1 /*
   2  * iterator.c
   3  *
   4  * Babeltrace Notification Iterator
   5  *
   6  * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/compiler.h>
  30 #include <babeltrace/ref.h>
  31 #include <babeltrace/graph/component.h>
  32 #include <babeltrace/graph/component-source-internal.h>
  33 #include <babeltrace/graph/component-class-internal.h>
  34 #include <babeltrace/graph/notification-iterator.h>
  35 #include <babeltrace/graph/notification-iterator-internal.h>
  36
  37 static
  38 void bt_notification_iterator_destroy(struct bt_object *obj)
  39 {
  40         struct bt_notification_iterator *iterator;
  41         struct bt_component_class *comp_class;
  42
  43         assert(obj);
  44         iterator = container_of(obj, struct bt_notification_iterator,
  45                         base);
  46         assert(iterator->component);
  47         comp_class = iterator->component->class;
  48
  49         /* Call user-defined destroy method */
  50         switch (comp_class->type) {
  51         case BT_COMPONENT_CLASS_TYPE_SOURCE:
  52         {
  53                 struct bt_component_class_source *source_class;
  54
  55                 source_class = container_of(comp_class, struct bt_component_class_source, parent);
  56
  57                 if (source_class->methods.iterator.finalize) {
  58                         source_class->methods.iterator.finalize(
  59                                 bt_private_notification_iterator_from_notification_iterator(iterator));
  60                 }
  61                 break;
  62         }
  63         case BT_COMPONENT_CLASS_TYPE_FILTER:
  64         {
  65                 struct bt_component_class_filter *filter_class;
  66
  67                 filter_class = container_of(comp_class, struct bt_component_class_filter, parent);
  68
  69                 if (filter_class->methods.iterator.finalize) {
  70                         filter_class->methods.iterator.finalize(
  71                                 bt_private_notification_iterator_from_notification_iterator(iterator));
  72                 }
  73                 break;
  74         }
  75         default:
  76                 /* Unreachable */
  77                 assert(0);
  78         }
  79
  80         BT_PUT(iterator->current_notification);
  81         BT_PUT(iterator->component);
  82         g_free(iterator);
  83 }
  84
  85 BT_HIDDEN
  86 struct bt_notification_iterator *bt_notification_iterator_create(
  87                 struct bt_component *component)
  88 {
  89         enum bt_component_class_type type;
  90         struct bt_notification_iterator *iterator = NULL;
  91
  92         if (!component) {
  93                 goto end;
  94         }
  95
  96         type = bt_component_get_class_type(component);
  97         switch (type) {
  98         case BT_COMPONENT_CLASS_TYPE_SOURCE:
  99         case BT_COMPONENT_CLASS_TYPE_FILTER:
 100                 break;
 101         default:
 102                 goto end;
 103         }
 104
 105         iterator = g_new0(struct bt_notification_iterator, 1);
 106         if (!iterator) {
 107                 goto end;
 108         }
 109
 110         iterator->component = bt_get(component);
 111         bt_object_init(iterator, bt_notification_iterator_destroy);
 112 end:
 113         return iterator;
 114 }
 115
 116 BT_HIDDEN
 117 enum bt_notification_iterator_status bt_notification_iterator_validate(
 118                 struct bt_notification_iterator *iterator)
 119 {
 120         enum bt_notification_iterator_status ret =
 121                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 122
 123         if (!iterator) {
 124                 ret = BT_NOTIFICATION_ITERATOR_STATUS_INVAL;
 125                 goto end;
 126         }
 127 end:
 128         return ret;
 129 }
 130
 131 void *bt_private_notification_iterator_get_user_data(
 132                 struct bt_private_notification_iterator *private_iterator)
 133 {
 134         struct bt_notification_iterator *iterator =
 135                 bt_notification_iterator_from_private(private_iterator);
 136
 137         return iterator ? iterator->user_data : NULL;
 138 }
 139
 140 enum bt_notification_iterator_status
 141 bt_private_notification_iterator_set_user_data(
 142                 struct bt_private_notification_iterator *private_iterator,
 143                 void *data)
 144 {
 145         enum bt_notification_iterator_status ret =
 146                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 147         struct bt_notification_iterator *iterator =
 148                 bt_notification_iterator_from_private(private_iterator);
 149
 150         if (!iterator) {
 151                 ret = BT_NOTIFICATION_ITERATOR_STATUS_INVAL;
 152                 goto end;
 153         }
 154
 155         iterator->user_data = data;
 156 end:
 157         return ret;
 158 }
 159
 160 struct bt_notification *bt_notification_iterator_get_notification(
 161                 struct bt_notification_iterator *iterator)
 162 {
 163         struct bt_notification *notification = NULL;
 164
 165         if (!iterator) {
 166                 goto end;
 167         }
 168
 169         notification = bt_get(iterator->current_notification);
 170
 171 end:
 172         return notification;
 173 }
 174
 175 enum bt_notification_iterator_status
 176 bt_notification_iterator_next(struct bt_notification_iterator *iterator)
 177 {
 178         struct bt_private_notification_iterator *priv_iterator =
 179                 bt_private_notification_iterator_from_notification_iterator(iterator);
 180         bt_component_class_notification_iterator_next_method next_method = NULL;
 181         struct bt_notification_iterator_next_return next_return;
 182         enum bt_notification_iterator_status status =
 183                 BT_NOTIFICATION_ITERATOR_STATUS_OK;
 184
 185         if (!iterator) {
 186                 status = BT_NOTIFICATION_ITERATOR_STATUS_INVAL;
 187                 goto end;
 188         }
 189
 190         assert(iterator->component);
 191         assert(iterator->component->class);
 192
 193         switch (iterator->component->class->type) {
 194         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 195         {
 196                 struct bt_component_class_source *source_class =
 197                         container_of(iterator->component->class,
 198                                 struct bt_component_class_source, parent);
 199
 200                 assert(source_class->methods.iterator.next);
 201                 next_method = source_class->methods.iterator.next;
 202                 break;
 203         }
 204         case BT_COMPONENT_CLASS_TYPE_FILTER:
 205         {
 206                 struct bt_component_class_filter *filter_class =
 207                         container_of(iterator->component->class,
 208                                 struct bt_component_class_filter, parent);
 209
 210                 assert(filter_class->methods.iterator.next);
 211                 next_method = filter_class->methods.iterator.next;
 212                 break;
 213         }
 214         default:
 215                 assert(false);
 216                 break;
 217         }
 218
 219         assert(next_method);
 220         next_return = next_method(priv_iterator);
 221         if (next_return.status == BT_NOTIFICATION_ITERATOR_STATUS_OK) {
 222                 if (!next_return.notification) {
 223                         status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 224                         goto end;
 225                 }
 226
 227                 BT_MOVE(iterator->current_notification,
 228                         next_return.notification);
 229         }
 230
 231 end:
 232         return next_return.status;
 233 }
 234
 235 struct bt_component *bt_notification_iterator_get_component(
 236                 struct bt_notification_iterator *iterator)
 237 {
 238         return bt_get(iterator->component);
 239 }
 240
 241 struct bt_private_component *
 242 bt_private_notification_iterator_get_private_component(
 243                 struct bt_private_notification_iterator *private_iterator)
 244 {
 245         return bt_private_component_from_component(
 246                 bt_notification_iterator_get_component(
 247                         bt_notification_iterator_from_private(private_iterator)));
 248 }
 249
 250 enum bt_notification_iterator_status bt_notification_iterator_seek_time(
 251                 struct bt_notification_iterator *iterator,
 252                 enum bt_notification_iterator_seek_origin seek_origin,
 253                 int64_t time)
 254 {
 255         enum bt_notification_iterator_status ret =
 256                         BT_NOTIFICATION_ITERATOR_STATUS_UNSUPPORTED;
 257         return ret;
 258 }