libuuu/notify.cpp

   1 /*
   2 * Copyright 2018 NXP.
   3 *
   4 * Redistribution and use in source and binary forms, with or without modification,
   5 * are permitted provided that the following conditions are met:
   6 *
   7 * Redistributions of source code must retain the above copyright notice, this
   8 * list of conditions and the following disclaimer.
   9 *
  10 * Redistributions in binary form must reproduce the above copyright notice, this
  11 * list of conditions and the following disclaimer in the documentation and/or
  12 * other materials provided with the distribution.
  13 *
  14 * Neither the name of the NXP Semiconductor nor the names of its
  15 * contributors may be used to endorse or promote products derived from this
  16 * software without specific prior written permission.
  17 *
  18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28 * POSSIBILITY OF SUCH DAMAGE.
  29 *
  30 */
  31
  32 #include "libuuu.h"
  33
  34 #include <chrono>
  35 #include <iostream>
  36 #include <map>
  37 #include <mutex>
  38 #include <thread>
  39
  40 using namespace std;
  41
  42 static map<uuu_notify_fun, void*> g_notification_map;
  43 static mutex g_mutex_notify;
  44
  45 using namespace std::chrono;
  46 static const time_point<steady_clock> g_now = steady_clock::now();
  47
  48 int uuu_register_notify_callback(uuu_notify_fun f, void *data)
  49 {
  50         std::lock_guard<mutex> lock(g_mutex_notify);
  51
  52         return g_notification_map.emplace(f, data).second ? 0 : 1;
  53 }
  54
  55 int uuu_unregister_notify_callback(uuu_notify_fun f)
  56 {
  57         std::lock_guard<mutex> lock(g_mutex_notify);
  58
  59         return g_notification_map.erase(f) > 0 ? 0 : 1;
  60 }
  61
  62 void call_notify(struct uuu_notify nf)
  63 {
  64         //Change RW lock later;
  65         std::lock_guard<mutex> lock(g_mutex_notify);
  66
  67         nf.id = std::hash<std::thread::id>{}(std::this_thread::get_id());
  68         nf.timestamp = static_cast<uint64_t>(
  69                 duration_cast<milliseconds>(steady_clock::now() - g_now).count());
  70
  71         for (const auto &item : g_notification_map)
  72         {
  73                 try {
  74                         item.first(nf, item.second);
  75                 } catch (const std::exception& e) {
  76                         std::cerr << "notify exception: " << e.what() << std::endl;
  77                 }
  78         }
  79 }