@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/json_utils.h

@@ -0,0 +1,172 @@
+#ifndef SRC_JSON_UTILS_H_
+#define SRC_JSON_UTILS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_concepts.h"
+
+#include <iomanip>
+#include <limits>
+#include <ostream>
+#include <string>
+#include <string_view>
+
+namespace node {
+
+constexpr bool NeedsJsonEscape(std::string_view str) {
+  for (const char c : str) {
+    if (c == '\\' || c == '"' || c < 0x20) return true;
+  }
+  return false;
+}
+
+std::string EscapeJsonChars(std::string_view str);
+std::string Reindent(const std::string& str, int indentation);
+
+// JSON compiler definitions.
+class JSONWriter {
+ public:
+  JSONWriter(std::ostream& out, bool compact)
+    : out_(out), compact_(compact) {}
+
+ private:
+  inline void indent() { indent_ += 2; }
+  inline void deindent() { indent_ -= 2; }
+  inline void advance() {
+    if (compact_) return;
+    for (int i = 0; i < indent_; i++) out_ << ' ';
+  }
+  inline void write_one_space() {
+    if (compact_) return;
+    out_ << ' ';
+  }
+  inline void write_new_line() {
+    if (compact_) return;
+    out_ << '\n';
+  }
+
+ public:
+  inline void json_start() {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    out_ << '{';
+    indent();
+    state_ = kObjectStart;
+  }
+
+  inline void json_end() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << '}';
+    state_ = kAfterValue;
+  }
+  template <typename T>
+  inline void json_objectstart(T key) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    out_ << '{';
+    indent();
+    state_ = kObjectStart;
+  }
+
+  template <typename T>
+  inline void json_arraystart(T key) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    out_ << '[';
+    indent();
+    state_ = kObjectStart;
+  }
+  inline void json_objectend() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << '}';
+    if (indent_ == 0) {
+      // Top-level object is complete, so end the line.
+      out_ << '\n';
+    }
+    state_ = kAfterValue;
+  }
+
+  inline void json_arrayend() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << ']';
+    state_ = kAfterValue;
+  }
+  template <typename T, typename U>
+  inline void json_keyvalue(const T& key, const U& value) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    write_value(value);
+    state_ = kAfterValue;
+  }
+
+  template <typename U>
+  inline void json_element(const U& value) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_value(value);
+    state_ = kAfterValue;
+  }
+
+  struct Null {};  // Usable as a JSON value.
+
+  struct ForeignJSON {
+    std::string as_string;
+  };
+
+ private:
+  template <NumericValue T>
+  inline void write_value(T number) {
+    if constexpr (std::is_same<T, bool>::value)
+      out_ << (number ? "true" : "false");
+    else
+      out_ << number;
+  }
+
+  inline void write_value(Null null) { out_ << "null"; }
+  inline void write_value(std::string_view str) { write_string(str); }
+
+  inline void write_value(const ForeignJSON& json) {
+    out_ << Reindent(json.as_string, indent_);
+  }
+
+  inline void write_string(std::string_view str) {
+    out_ << '"';
+    if (NeedsJsonEscape(str))  // only create temporary std::string if necessary
+      out_ << EscapeJsonChars(str);
+    else
+      out_ << str;
+    out_ << '"';
+  }
+
+  enum JSONState { kObjectStart, kAfterValue };
+  std::ostream& out_;
+  bool compact_;
+  int indent_ = 0;
+  int state_ = kObjectStart;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_JSON_UTILS_H_

package/src/headers/26/large_pages/node_large_page.h

@@ -0,0 +1,34 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom
+// the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+// OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// SPDX-License-Identifier: MIT
+
+#ifndef SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_
+#define SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+int MapStaticCodeToLargePages();
+const char* LargePagesError(int status);
+}  // namespace node
+
+#endif  // NODE_WANT_INTERNALS
+#endif  // SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_

package/src/headers/26/lru_cache-inl.h

@@ -0,0 +1,69 @@
+#ifndef SRC_LRU_CACHE_INL_H_
+#define SRC_LRU_CACHE_INL_H_
+
+#include <list>
+#include <unordered_map>
+#include <utility>
+
+template <typename key_t, typename value_t>
+class LRUCache {
+ public:
+  using key_value_pair_t = typename std::pair<key_t, value_t>;
+  using iterator = typename std::list<key_value_pair_t>::iterator;
+  using const_iterator = typename std::list<key_value_pair_t>::const_iterator;
+
+  const_iterator begin() const { return lru_list_.begin(); }
+  const_iterator end() const { return lru_list_.end(); }
+
+  explicit LRUCache(size_t capacity) : capacity_(capacity) {}
+
+  void Put(const key_t& key, const value_t& value) {
+    auto it = lookup_map_.find(key);
+    if (it != lookup_map_.end()) {
+      lru_list_.erase(it->second);
+      lookup_map_.erase(it);
+    }
+
+    lru_list_.push_front(std::make_pair(key, value));
+    lookup_map_[key] = lru_list_.begin();
+
+    if (lookup_map_.size() > capacity_) {
+      auto last = lru_list_.end();
+      last--;
+      lookup_map_.erase(last->first);
+      lru_list_.pop_back();
+    }
+  }
+
+  value_t& Get(const key_t& key) {
+    auto it = lookup_map_.find(key);
+    lru_list_.splice(lru_list_.begin(), lru_list_, it->second);
+    return it->second->second;
+  }
+
+  void Erase(const key_t& key) {
+    auto it = lookup_map_.find(key);
+    if (it != lookup_map_.end()) {
+      lru_list_.erase(it->second);
+      lookup_map_.erase(it);
+    }
+  }
+
+  bool Exists(const key_t& key) const { return lookup_map_.count(key) > 0; }
+
+  size_t Size() const { return lookup_map_.size(); }
+
+  size_t Capacity() const { return capacity_; }
+
+  void Clear() {
+    lru_list_.clear();
+    lookup_map_.clear();
+  }
+
+ private:
+  std::list<key_value_pair_t> lru_list_;
+  std::unordered_map<key_t, iterator> lookup_map_;
+  size_t capacity_;
+};
+
+#endif  // SRC_LRU_CACHE_INL_H_