tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

ParamTraits_STL.h (3691B)

      1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 #ifndef MOZILLA_PARAMTRAITS_STL_H
      7 #define MOZILLA_PARAMTRAITS_STL_H
      8 
      9 #include "ipc/IPCMessageUtils.h"
     10 
     11 namespace IPC {
     12 
     13 template <typename U, size_t N>
     14 struct ParamTraits<std::array<U, N>> final {
     15  using T = std::array<U, N>;
     16 
     17  static void Write(MessageWriter* const writer, const T& in) {
     18    for (const auto& v : in) {
     19      WriteParam(writer, v);
     20    }
     21  }
     22 
     23  static bool Read(MessageReader* const reader, T* const out) {
     24    for (auto& v : *out) {
     25      if (!ReadParam(reader, &v)) return false;
     26    }
     27    return true;
     28  }
     29 };
     30 
     31 // -
     32 
     33 template <typename U, size_t N>
     34 struct ParamTraits<U[N]> final {
     35  using T = U[N];
     36  static constexpr size_t kByteSize = sizeof(U) * N;
     37 
     38  static_assert(std::is_trivial<U>::value);
     39 
     40  static void Write(MessageWriter* const writer, const T& in) {
     41    writer->WriteBytes(in, kByteSize);
     42  }
     43 
     44  static bool Read(MessageReader* const reader, T* const out) {
     45    if (!reader->HasBytesAvailable(kByteSize)) {
     46      return false;
     47    }
     48    return reader->ReadBytesInto(*out, kByteSize);
     49  }
     50 };
     51 
     52 // -
     53 
     54 template <class U>
     55 struct ParamTraits<std::optional<U>> final {
     56  using T = std::optional<U>;
     57 
     58  static void Write(MessageWriter* const writer, const T& in) {
     59    WriteParam(writer, bool{in});
     60    if (in) {
     61      WriteParam(writer, *in);
     62    }
     63  }
     64 
     65  static bool Read(MessageReader* const reader, T* const out) {
     66    bool isSome;
     67    if (!ReadParam(reader, &isSome)) return false;
     68 
     69    if (!isSome) {
     70      out->reset();
     71      return true;
     72    }
     73    out->emplace();
     74    return ReadParam(reader, &**out);
     75  }
     76 };
     77 
     78 // -
     79 
     80 template <class A, class B>
     81 struct ParamTraits<std::pair<A, B>> final {
     82  using T = std::pair<A, B>;
     83 
     84  static void Write(MessageWriter* const writer, const T& in) {
     85    WriteParam(writer, in.first);
     86    WriteParam(writer, in.second);
     87  }
     88 
     89  static bool Read(MessageReader* const reader, T* const out) {
     90    bool ok = true;
     91    ok = ok && ReadParam(reader, &out->first);
     92    ok = ok && ReadParam(reader, &out->second);
     93    return ok;
     94  }
     95 };
     96 
     97 // -
     98 
     99 template <class K, class V, class H, class E>
    100 struct ParamTraits<std::unordered_map<K, V, H, E>> final {
    101  using T = std::unordered_map<K, V, H, E>;
    102 
    103  static void Write(MessageWriter* const writer, const T& in) {
    104    const auto size = uint64_t{in.size()};
    105    WriteParam(writer, size);
    106    for (const auto& pair : in) {
    107      WriteParam(writer, pair);
    108    }
    109  }
    110 
    111  static bool Read(MessageReader* const reader, T* const out) {
    112    out->clear();
    113 
    114    auto size = uint64_t{};
    115    if (!ReadParam(reader, &size)) return false;
    116 
    117    out->reserve(static_cast<size_t>(size));
    118    for (const auto i : mozilla::IntegerRange(size)) {
    119      (void)i;
    120      auto pair = std::pair<K, V>{};
    121      if (!ReadParam(reader, &pair)) return false;
    122      out->insert(pair);
    123    }
    124    return true;
    125  }
    126 };
    127 
    128 // -
    129 
    130 // template <class... T>
    131 // struct ParamTraits<std::tuple<T...>> final {
    132 //   using T = std::tuple<T...>;
    133 //
    134 //   static void Write(MessageWriter* const writer, const T& in) {
    135 //     mozilla::MapTuple(aArg, [&](const auto& field) {
    136 //       WriteParam(writer, field);
    137 //       return true;  // ignored
    138 //     });
    139 //   }
    140 //
    141 //   static bool Read(MessageReader* const reader, T* const out) {
    142 //     bool ok = true;
    143 //     mozilla::MapTuple(*aArg, [&](auto& field) {
    144 //       ok = ok && ReadParam(reader, &field);
    145 //       return true;  // ignored
    146 //     });
    147 //     return ok;
    148 //   }
    149 // };
    150 
    151 }  // namespace IPC
    152 
    153 #endif