pv/metadata_obj.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2020 Soeren Apel <soeren@apelpie.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "metadata_obj.hpp"
  21
  22
  23 namespace pv {
  24
  25 const char* MetadataObjectNames[MetadataObjectTypeCount] = {
  26         "main_view_range",
  27         "selection",
  28         "time_marker"
  29 };
  30
  31 const char* MetadataValueNames[MetadataValueTypeCount] = {
  32         "start_sample",
  33         "end_sample"
  34         "text"
  35 };
  36
  37
  38 void MetadataObjObserverInterface::on_metadata_object_created(MetadataObject* obj)
  39 {
  40         (void)obj;
  41 }
  42
  43 void MetadataObjObserverInterface::on_metadata_object_deleted(MetadataObject* obj)
  44 {
  45         (void)obj;
  46 }
  47
  48 void MetadataObjObserverInterface::on_metadata_object_changed(MetadataObject* obj,
  49         MetadataValueType value_type)
  50 {
  51         (void)obj;
  52         (void)value_type;
  53 }
  54
  55
  56 MetadataObject::MetadataObject(MetadataObjManager* obj_manager, uint32_t obj_id,
  57         MetadataObjectType obj_type) :
  58         obj_manager_(obj_manager),
  59         id_(obj_id),
  60         type_(obj_type)
  61 {
  62         // Make sure we accept all value type indices
  63         values_.resize(MetadataValueTypeCount);
  64 }
  65
  66 uint32_t MetadataObject::id() const
  67 {
  68         return id_;
  69 }
  70
  71 MetadataObjectType MetadataObject::type() const
  72 {
  73         return type_;
  74 }
  75
  76 void MetadataObject::set_value(MetadataValueType value_type, const QVariant& value)
  77 {
  78         values_.at((uint8_t)value_type) = value;
  79         obj_manager_->notify_observers(this, value_type);
  80 }
  81
  82 QVariant MetadataObject::value(MetadataValueType value_type) const
  83 {
  84         return values_.at((uint8_t)value_type);
  85 }
  86
  87
  88 MetadataObject* MetadataObjManager::create_object(MetadataObjectType obj_type)
  89 {
  90         // Note: This function is not reentrant as race conditions between
  91         // emplace_back() and back() may occur
  92
  93         objects_.emplace_back(this, objects_.size(), obj_type);
  94         MetadataObject* obj = &(objects_.back());
  95
  96         for (MetadataObjObserverInterface *cb : callbacks_)
  97                 cb->on_metadata_object_created(obj);
  98
  99         return obj;
 100 }
 101
 102 void MetadataObjManager::delete_object(uint32_t obj_id)
 103 {
 104         for (MetadataObjObserverInterface *cb : callbacks_)
 105                 cb->on_metadata_object_deleted(&(objects_.at(obj_id)));
 106
 107         objects_.erase(std::remove_if(objects_.begin(), objects_.end(),
 108                 [&](MetadataObject obj) { return obj.id() == obj_id; }),
 109                 objects_.end());
 110 }
 111
 112 MetadataObject* MetadataObjManager::find_object_by_type(MetadataObjectType obj_type)
 113 {
 114         for (MetadataObject& obj : objects_)
 115                 if (obj.type() == obj_type)
 116                         return &obj;
 117
 118         return nullptr;
 119 }
 120
 121 MetadataObject* MetadataObjManager::object(uint32_t obj_id)
 122 {
 123         return &(objects_.at(obj_id));
 124 }
 125
 126 void MetadataObjManager::add_observer(MetadataObjObserverInterface *cb)
 127 {
 128         callbacks_.emplace_back(cb);
 129 }
 130
 131 void MetadataObjManager::remove_observer(MetadataObjObserverInterface *cb)
 132 {
 133         for (auto cb_it = callbacks_.begin(); cb_it != callbacks_.end(); cb_it++)
 134                 if (*cb_it == cb) {
 135                         callbacks_.erase(cb_it);
 136                         break;
 137                 }
 138 }
 139
 140 void MetadataObjManager::save_objects(QSettings &settings) const
 141 {
 142         (void)settings;
 143 }
 144
 145 void MetadataObjManager::restore_objects(QSettings &settings)
 146 {
 147         (void)settings;
 148 }
 149
 150 void MetadataObjManager::notify_observers(MetadataObject* obj,
 151         MetadataValueType changed_value)
 152 {
 153         for (MetadataObjObserverInterface *cb : callbacks_)
 154                 cb->on_metadata_object_changed(obj, changed_value);
 155 }
 156
 157 } // namespace pv