modules/gapi/include/opencv2/gapi/s11n.hpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2020 Intel Corporation
   6
   7 #ifndef OPENCV_GAPI_S11N_HPP
   8 #define OPENCV_GAPI_S11N_HPP
   9
  10 #include <vector>
  11 #include <map>
  12 #include <unordered_map>
  13 #include <opencv2/gapi/gcomputation.hpp>
  14
  15 namespace cv {
  16 namespace gapi {
  17
  18 namespace detail {
  19     GAPI_EXPORTS cv::GComputation getGraph(const std::vector<char> &p);
  20 } // namespace detail
  21
  22 namespace detail {
  23     GAPI_EXPORTS cv::GMetaArgs getMetaArgs(const std::vector<char> &p);
  24 } // namespace detail
  25
  26 namespace detail {
  27     GAPI_EXPORTS cv::GRunArgs getRunArgs(const std::vector<char> &p);
  28 } // namespace detail
  29
  30 GAPI_EXPORTS std::vector<char> serialize(const cv::GComputation &c);
  31 //namespace{
  32
  33 template<typename T> static inline
  34 T deserialize(const std::vector<char> &p);
  35
  36 //} //ananymous namespace
  37
  38 GAPI_EXPORTS std::vector<char> serialize(const cv::GMetaArgs&);
  39 GAPI_EXPORTS std::vector<char> serialize(const cv::GRunArgs&);
  40
  41 template<> inline
  42 cv::GComputation deserialize(const std::vector<char> &p) {
  43     return detail::getGraph(p);
  44 }
  45
  46 template<> inline
  47 cv::GMetaArgs deserialize(const std::vector<char> &p) {
  48     return detail::getMetaArgs(p);
  49 }
  50
  51 template<> inline
  52 cv::GRunArgs deserialize(const std::vector<char> &p) {
  53     return detail::getRunArgs(p);
  54 }
  55
  56 } // namespace gapi
  57 } // namespace cv
  58
  59 namespace cv {
  60 namespace gapi {
  61 namespace s11n {
  62 struct GAPI_EXPORTS IOStream {
  63     virtual ~IOStream() = default;
  64     // Define the native support for basic C++ types at the API level:
  65     virtual IOStream& operator<< (bool) = 0;
  66     virtual IOStream& operator<< (char) = 0;
  67     virtual IOStream& operator<< (unsigned char) = 0;
  68     virtual IOStream& operator<< (short) = 0;
  69     virtual IOStream& operator<< (unsigned short) = 0;
  70     virtual IOStream& operator<< (int) = 0;
  71     virtual IOStream& operator<< (uint32_t) = 0;
  72     virtual IOStream& operator<< (uint64_t) = 0;
  73     virtual IOStream& operator<< (float) = 0;
  74     virtual IOStream& operator<< (double) = 0;
  75     virtual IOStream& operator<< (const std::string&) = 0;
  76 };
  77
  78 struct GAPI_EXPORTS IIStream {
  79     virtual ~IIStream() = default;
  80     virtual IIStream& operator>> (bool &) = 0;
  81     virtual IIStream& operator>> (std::vector<bool>::reference) = 0;
  82     virtual IIStream& operator>> (char &) = 0;
  83     virtual IIStream& operator>> (unsigned char &) = 0;
  84     virtual IIStream& operator>> (short &) = 0;
  85     virtual IIStream& operator>> (unsigned short &) = 0;
  86     virtual IIStream& operator>> (int &) = 0;
  87     virtual IIStream& operator>> (float &) = 0;
  88     virtual IIStream& operator>> (double &) = 0;
  89     virtual IIStream& operator >> (uint32_t &) = 0;
  90     virtual IIStream& operator >> (uint64_t &) = 0;
  91     virtual IIStream& operator>> (std::string &) = 0;
  92 };
  93
  94 ////////////////////////////////////////////////////////////////////////////////
  95 ////////////////////////////////////////////////////////////////////////////////
  96 // S11N operators
  97 // Note: operators for basic types are defined in IIStream/IOStream
  98
  99 // OpenCV types ////////////////////////////////////////////////////////////////
 100
 101 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point &pt);
 102 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Point &pt);
 103
 104 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Size &sz);
 105 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Size &sz);
 106
 107 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Rect &rc);
 108 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Rect &rc);
 109
 110 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Scalar &s);
 111 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Scalar &s);
 112
 113 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Mat &m);
 114 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Mat &m);
 115
 116 // Generic STL types ////////////////////////////////////////////////////////////////
 117 template<typename K, typename V>
 118 IOStream& operator<< (IOStream& os, const std::map<K, V> &m) {
 119     const uint32_t sz = static_cast<uint32_t>(m.size());
 120     os << sz;
 121     for (const auto& it : m) os << it.first << it.second;
 122     return os;
 123 }
 124 template<typename K, typename V>
 125 IIStream& operator>> (IIStream& is, std::map<K, V> &m) {
 126     m.clear();
 127     uint32_t sz = 0u;
 128     is >> sz;
 129     for (std::size_t i = 0; i < sz; ++i) {
 130         K k{};
 131         V v{};
 132         is >> k >> v;
 133         m[k] = v;
 134     }
 135     return is;
 136 }
 137 template<typename K, typename V>
 138 IOStream& operator<< (IOStream& os, const std::unordered_map<K, V> &m) {
 139     const uint32_t sz = static_cast<uint32_t>(m.size());
 140     os << sz;
 141     for (auto &&it : m) os << it.first << it.second;
 142     return os;
 143 }
 144 template<typename K, typename V>
 145 IIStream& operator>> (IIStream& is, std::unordered_map<K, V> &m) {
 146     m.clear();
 147     uint32_t sz = 0u;
 148     is >> sz;
 149     for (std::size_t i = 0; i < sz; ++i) {
 150         K k{};
 151         V v{};
 152         is >> k >> v;
 153         m[k] = v;
 154     }
 155     return is;
 156 }
 157 template<typename T>
 158 IOStream& operator<< (IOStream& os, const std::vector<T> &ts) {
 159     const uint32_t sz = static_cast<uint32_t>(ts.size());
 160     os << sz;
 161     for (auto &&v : ts) os << v;
 162     return os;
 163 }
 164 template<typename T>
 165 IIStream& operator>> (IIStream& is, std::vector<T> &ts) {
 166     uint32_t sz = 0u;
 167     is >> sz;
 168     if (sz == 0u) {
 169         ts.clear();
 170     }
 171     else {
 172         ts.resize(sz);
 173         for (std::size_t i = 0; i < sz; ++i) is >> ts[i];
 174     }
 175     return is;
 176 }
 177
 178 namespace detail {
 179     // Will be used along with default types if possible in specific cases (compile args, etc)
 180     // Note: actual implementation is defined by user
 181     template<typename T>
 182     struct GAPI_EXPORTS S11N {
 183         static void serialize(IOStream &, const T &) {}
 184         static T deserialize(IIStream &) { T t; return t; }
 185     };
 186 } // namespace detail
 187 } // namespace s11n
 188 } // namespace gapi
 189 } // namespace cv
 190
 191 #endif // OPENCV_GAPI_S11N_HPP