@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/include/eosio/stream.hpp

@@ -1,231 +0,0 @@
-#pragma once
-
-#include "check.hpp"
-#include <string>
-#include <string_view>
-#include <vector>
-#include <type_traits>
-#include <string.h>
-#include <algorithm>
-#include <system_error>
-#include <string_view>
-
-namespace eosio {
-
-enum class stream_error {
-   no_error,
-   overrun,
-   underrun,
-   float_error,
-   varuint_too_big,
-   invalid_varuint_encoding,
-   bad_variant_index,
-   invalid_asset_format,
-   array_size_mismatch,
-   invalid_name_char,
-   invalid_name_char13,
-   name_too_long,
-   json_writer_error, // !!!
-}; // stream_error
-
-constexpr inline std::string_view convert_stream_error(stream_error e) {
-   switch (e) {
-         // clang-format off
-      case stream_error::no_error:                 return "No error";
-      case stream_error::overrun:                  return "Stream overrun";
-      case stream_error::underrun:                 return "Stream underrun";
-      case stream_error::float_error:              return "Float error";
-      case stream_error::varuint_too_big:          return "Varuint too big";
-      case stream_error::invalid_varuint_encoding: return "Invalid varuint encoding";
-      case stream_error::bad_variant_index:        return "Bad variant index";
-      case stream_error::invalid_asset_format:     return "Invalid asset format";
-      case stream_error::array_size_mismatch:      return "T[] size and unpacked size don't match";
-      case stream_error::invalid_name_char:        return "character is not in allowed character set for names";
-      case stream_error::invalid_name_char13:      return "thirteenth character in name cannot be a letter that comes after j";
-      case stream_error::name_too_long:            return "string is too long to be a valid name";
-      case stream_error::json_writer_error: return "Error writing json";
-         // clang-format on
-
-      default: return "unknown";
-   }
-}
-
-template<typename T>
-constexpr bool has_bitwise_serialization() {
-   if constexpr (std::is_arithmetic_v<T>) {
-      return true;
-   } else if constexpr (std::is_enum_v<T>) {
-      static_assert(!std::is_convertible_v<T, std::underlying_type_t<T>>, "Serializing unscoped enum");
-      return true;
-   } else {
-      return false;
-   }
-}
-
-template <int max_size>
-struct small_buffer {
-   char  data[max_size];
-   char* pos{ data };
-
-   void reverse() { std::reverse(data, pos); }
-};
-
-struct vector_stream {
-   std::vector<char>& data;
-   vector_stream(std::vector<char>& data) : data(data) {}
-
-   void write(char c) {
-      data.push_back(c);
-   }
-   void write(const void* src, std::size_t sz) {
-      auto s = reinterpret_cast<const char*>(src);
-      data.insert( data.end(), s, s + sz );
-   }
-   template <typename T>
-   void write_raw(const T& v) {
-      write(&v, sizeof(v));
-   }
-};
-
-struct fixed_buf_stream {
-   char* pos;
-   char* end;
-
-   fixed_buf_stream(char* pos, size_t size) : pos{ pos }, end{ pos + size } {}
-
-   void write(char c) {
-      check( pos < end, convert_stream_error(stream_error::overrun) );
-      *pos++ = c;
-   }
-
-   void write(const void* src, std::size_t sz) {
-      check( pos + sz <= end, convert_stream_error(stream_error::overrun) );
-      memcpy(pos, src, sz);
-      pos += sz;
-   }
-
-   template <int Size>
-   void write(const char (&src)[Size]) {
-      write(src, Size);
-   }
-
-   template <typename T>
-   void write_raw(const T& v) {
-      write(&v, sizeof(v));
-   }
-};
-
-struct size_stream {
-   size_t size = 0;
-
-   void write(char c) {
-      ++size;
-   }
-
-   void write(const void* src, std::size_t sz) {
-      size += sz;
-   }
-
-   template <int Size>
-   void write(const char (&src)[Size]) {
-      size += Size;
-   }
-
-   template <typename T>
-   void write_raw(const T& v) {
-      size += sizeof(v);
-   }
-};
-
-template <typename S>
-void increase_indent(S&) {
-}
-
-template <typename S>
-void decrease_indent(S&) {
-}
-
-template <typename S>
-void write_colon(S& s) {
-   s.write(':');
-}
-
-template <typename S>
-void write_newline(S&) {
-}
-
-template <typename Base>
-struct pretty_stream : Base {
-   using Base::Base;
-   int               indent_size = 4;
-   std::vector<char> current_indent;
-};
-
-template <typename S>
-void increase_indent(pretty_stream<S>& s) {
-   s.current_indent.resize(s.current_indent.size() + s.indent_size, ' ');
-}
-
-template <typename S>
-void decrease_indent(pretty_stream<S>& s) {
-   check( s.current_indent.size() >= s.indent_size,
-         convert_stream_error(stream_error::overrun) );
-   s.current_indent.resize(s.current_indent.size() - s.indent_size);
-}
-
-template <typename S>
-void write_colon(pretty_stream<S>& s) {
-   s.write(": ", 2);
-}
-
-template <typename S>
-void write_newline(pretty_stream<S>& s) {
-   s.write('\n');
-   s.write(s.current_indent.data(), s.current_indent.size());
-}
-
-struct input_stream {
-   const char* pos;
-   const char* end;
-
-   input_stream() : pos{ nullptr }, end{ nullptr } {}
-   input_stream(const char* pos, size_t size) : pos{ pos }, end{ pos + size } {}
-   input_stream(const char* pos, const char* end) : pos{ pos }, end{ end } {}
-   input_stream(const std::vector<char>& v) : pos{ v.data() }, end{ v.data() + v.size() } {}
-   input_stream(std::string_view v) : pos{ v.data() }, end{ v.data() + v.size() } {}
-   input_stream(const input_stream&) = default;
-
-   input_stream& operator=(const input_stream&) = default;
-
-   size_t remaining() const { return end - pos; }
-
-   void check_available(size_t size) const {
-      check( size <= std::size_t(end-pos), convert_stream_error(stream_error::overrun) );
-   }
-
-   auto get_pos() const { return pos; }
-
-   void read(void* dest, size_t size) {
-      check( size <= size_t(end-pos), convert_stream_error(stream_error::overrun) );
-      memcpy(dest, pos, size);
-      pos += size;
-   }
-
-   template <typename T>
-   void read_raw(T& dest) {
-      read(&dest, sizeof(dest));
-   }
-
-   void skip(size_t size) {
-      check( size <= size_t(end-pos), convert_stream_error(stream_error::overrun) );
-      pos += size;
-   }
-
-   void read_reuse_storage(const char*& result, size_t size) {
-      check( size <= size_t(end-pos), convert_stream_error(stream_error::overrun) );
-      result = pos;
-      pos += size;
-   }
-};
-
-} // namespace eosio

package/include/eosio/symbol.hpp

@@ -1,300 +0,0 @@
-/**
- *  @file
- *  @copyright defined in eos/LICENSE
- */
-#pragma once
-
-#include "chain_conversions.hpp"
-#include "check.hpp"
-#include "from_json.hpp"
-#include "name.hpp"
-#include "operators.hpp"
-#include "reflection.hpp"
-
-#include <limits>
-#include <string_view>
-#include <tuple>
-
-namespace eosio {
-/**
- *  @defgroup symbol Symbol
- *  @ingroup core
- *  @brief Defines C++ API for managing symbols
- */
-
-/**
- *  Stores the symbol code as a uint64_t value
- *
- *  @ingroup symbol
- */
-class symbol_code {
- public:
-   /**
-    * Default constructor, construct a new symbol_code
-    *
-    * @brief Construct a new symbol_code object defaulting to a value of 0
-    *
-    */
-   constexpr symbol_code() : value(0) {}
-
-   /**
-    * Construct a new symbol_code given a scoped enumerated type of raw (uint64_t).
-    *
-    * @brief Construct a new symbol_code object initialising value with raw
-    * @param raw - The raw value which is a scoped enumerated type of unit64_t
-    *
-    */
-   constexpr explicit symbol_code(uint64_t raw) : value(raw) {}
-
-   /**
-    * Construct a new symbol_code given an string.
-    *
-    * @brief Construct a new symbol_code object initialising value with str
-    * @param str - The string value which validated then converted to unit64_t
-    *
-    */
-   constexpr explicit symbol_code(std::string_view str) : value(0) {
-      if (str.size() > 7) {
-         eosio::check(false, "string is too long to be a valid symbol_code");
-      }
-      for (auto itr = str.rbegin(); itr != str.rend(); ++itr) {
-         if (*itr < 'A' || *itr > 'Z') {
-            eosio::check(false, "only uppercase letters allowed in symbol_code string");
-         }
-         value <<= 8;
-         value |= *itr;
-      }
-   }
-
-   /**
-    * Checks if the symbol code is valid
-    * @return true - if symbol is valid
-    */
-   constexpr bool is_valid() const {
-      auto sym = value;
-      for (int i = 0; i < 7; i++) {
-         char c = (char)(sym & 0xFF);
-         if (!('A' <= c && c <= 'Z'))
-            return false;
-         sym >>= 8;
-         if (!(sym & 0xFF)) {
-            do {
-               sym >>= 8;
-               if ((sym & 0xFF))
-                  return false;
-               i++;
-            } while (i < 7);
-         }
-      }
-      return true;
-   }
-
-   /**
-    * Returns the character length of the provided symbol
-    *
-    * @return length - character length of the provided symbol
-    */
-   constexpr uint32_t length() const {
-      auto     sym = value;
-      uint32_t len = 0;
-      while (sym & 0xFF && len <= 7) {
-         len++;
-         sym >>= 8;
-      }
-      return len;
-   }
-
-   /**
-    *  Returns the suffix of the %name
-    */
-   constexpr name suffix() const {
-      uint32_t remaining_bits_after_last_actual_dot = 0;
-      uint32_t tmp                                  = 0;
-      for (int32_t remaining_bits = 59; remaining_bits >= 4;
-           remaining_bits -= 5) { // Note: remaining_bits must remain signed integer
-         // Get characters one-by-one in name in order from left to right (not including the 13th character)
-         auto c = (value >> remaining_bits) & 0x1Full;
-         if (!c) { // if this character is a dot
-            tmp = static_cast<uint32_t>(remaining_bits);
-         } else { // if this character is not a dot
-            remaining_bits_after_last_actual_dot = tmp;
-         }
-      }
-
-      uint64_t thirteenth_character = value & 0x0Full;
-      if (thirteenth_character) { // if 13th character is not a dot
-         remaining_bits_after_last_actual_dot = tmp;
-      }
-
-      if (remaining_bits_after_last_actual_dot ==
-          0) // there is no actual dot in the %name other than potentially leading dots
-         return name{ value };
-
-      // At this point remaining_bits_after_last_actual_dot has to be within the range of 4 to 59 (and restricted to
-      // increments of 5).
-
-      // Mask for remaining bits corresponding to characters after last actual dot, except for 4 least significant bits
-      // (corresponds to 13th character).
-      uint64_t mask  = (1ull << remaining_bits_after_last_actual_dot) - 16;
-      uint32_t shift = 64 - remaining_bits_after_last_actual_dot;
-
-      return name{ ((value & mask) << shift) + (thirteenth_character << (shift - 1)) };
-   }
-
-   /**
-    * Casts a symbol code to raw
-    *
-    * @return Returns an instance of raw based on the value of a symbol_code
-    */
-   constexpr uint64_t raw() const { return value; }
-
-   /**
-    * Explicit cast to bool of the symbol_code
-    *
-    * @return Returns true if the symbol_code is set to the default value of 0 else true.
-    */
-   constexpr explicit operator bool() const { return value != 0; }
-
-   /**
-    *  Returns the name value as a string by calling write_as_string() and returning the buffer produced by
-    * write_as_string()
-    */
-   std::string to_string() const { return symbol_code_to_string(value); }
-
-   uint64_t value = 0;
-};
-
-EOSIO_REFLECT(symbol_code, value);
-EOSIO_COMPARE(symbol_code);
-
-template <typename S>
-void to_json(const symbol_code& obj, S& stream) {
-   to_json(symbol_code_to_string(obj.value), stream);
-}
-
-template <typename S>
-void from_json(symbol_code& obj, S& stream) {
-   auto s = stream.get_string();
-   check(string_to_symbol_code(obj.value, s.data(), s.data() + s.size()),
-      convert_json_error(eosio::from_json_error::expected_symbol_code));
-}
-
-/**
- *  Stores information about a symbol, the symbol can be 7 characters long.
- *
- *  @ingroup symbol
- */
-class symbol {
- public:
-   /**
-    * Construct a new symbol object defaulting to a value of 0
-    */
-   constexpr symbol() : value(0) {}
-
-   /**
-    * Construct a new symbol given a scoped enumerated type of raw (uint64_t).
-    *
-    * @param raw - The raw value which is a scoped enumerated type of unit64_t
-    */
-   constexpr explicit symbol(uint64_t raw) : value(raw) {}
-
-   /**
-    * Construct a new symbol given a symbol_code and a uint8_t precision.
-    *
-    * @param sc - The symbol_code
-    * @param precision - The number of decimal places used for the symbol
-    */
-   constexpr symbol(symbol_code sc, uint8_t precision) : value((sc.raw() << 8) | static_cast<uint64_t>(precision)) {}
-
-   /**
-    * Construct a new symbol given a string and a uint8_t precision.
-    *
-    * @param ss - The string containing the symbol
-    * @param precision - The number of decimal places used for the symbol
-    */
-   constexpr symbol(std::string_view ss, uint8_t precision)
-       : value((symbol_code(ss).raw() << 8) | static_cast<uint64_t>(precision)) {}
-
-   /**
-    * Is this symbol valid
-    */
-   constexpr bool is_valid() const { return code().is_valid(); }
-
-   /**
-    * This symbol's precision
-    */
-   constexpr uint8_t precision() const { return static_cast<uint8_t>(value & 0xFFull); }
-
-   /**
-    * Returns representation of symbol name
-    */
-   constexpr symbol_code code() const { return symbol_code{ value >> 8 }; }
-
-   /**
-    * Returns uint64_t repreresentation of the symbol
-    */
-   constexpr uint64_t raw() const { return value; }
-
-   constexpr explicit operator bool() const { return value != 0; }
-
-   std::string to_string() const { return symbol_to_string(value); }
-
-   uint64_t value = 0;
-};
-
-EOSIO_REFLECT(symbol, value);
-EOSIO_COMPARE(symbol);
-
-template <typename S>
-void to_json(const symbol& obj, S& stream) {
-   to_json(symbol_to_string(obj.value), stream);
-}
-
-template <typename S>
-void from_json(symbol& obj, S& stream) {
-   auto s = stream.get_string();
-   check(string_to_symbol(obj.value, s.data(), s.data() + s.size()),
-      convert_json_error(eosio::from_json_error::expected_symbol));
-}
-
-/**
- *  Extended asset which stores the information of the owner of the symbol
- *
- *  @ingroup symbol
- */
-class extended_symbol {
- public:
-   /**
-    * Default constructor, construct a new extended_symbol
-    */
-   constexpr extended_symbol() {}
-
-   /**
-    * Construct a new symbol_code object initialising symbol and contract with the passed in symbol and name
-    *
-    * @param sym - The symbol
-    * @param con - The name of the contract
-    */
-   constexpr extended_symbol(symbol s, name con) : sym(s), contract(con) {}
-
-   /**
-    * Returns the symbol in the extended_contract
-    *
-    * @return symbol
-    */
-   constexpr symbol get_symbol() const { return sym; }
-
-   /**
-    * Returns the name of the contract in the extended_symbol
-    *
-    * @return name
-    */
-   constexpr name get_contract() const { return contract; }
-
-   symbol sym;      ///< the symbol
-   name   contract; ///< the token contract hosting the symbol
-};
-
-EOSIO_REFLECT(extended_symbol, sym, contract);
-EOSIO_COMPARE(extended_symbol);
-} // namespace eosio