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

package/external/rapidjson/travis-doxygen.sh

@@ -1,121 +0,0 @@
-#!/bin/bash
-# Update Doxygen documentation after push to 'master'.
-# Author: @pah
-
-set -e
-
-DOXYGEN_VER=doxygen-1.8.13
-DOXYGEN_TAR=${DOXYGEN_VER}.linux.bin.tar.gz
-DOXYGEN_URL="http://ftp.stack.nl/pub/users/dimitri/${DOXYGEN_TAR}"
-
-: ${GITHUB_REPO:="Tencent/rapidjson"}
-GITHUB_HOST="github.com"
-GITHUB_CLONE="git://${GITHUB_HOST}/${GITHUB_REPO}"
-GITHUB_URL="https://${GITHUB_HOST}/${GITHUB_PUSH-${GITHUB_REPO}}"
-
-# if not set, ignore password
-#GIT_ASKPASS="${TRAVIS_BUILD_DIR}/gh_ignore_askpass.sh"
-
-skip() {
-	echo "$@" 1>&2
-	echo "Exiting..." 1>&2
-	exit 0
-}
-
-abort() {
-	echo "Error: $@" 1>&2
-	echo "Exiting..." 1>&2
-	exit 1
-}
-
-# TRAVIS_BUILD_DIR not set, exiting
-[ -d "${TRAVIS_BUILD_DIR-/nonexistent}" ] || \
-	abort '${TRAVIS_BUILD_DIR} not set or nonexistent.'
-
-# check for pull-requests
-[ "${TRAVIS_PULL_REQUEST}" = "false" ] || \
-	skip "Not running Doxygen for pull-requests."
-
-# check for branch name
-[ "${TRAVIS_BRANCH}" = "master" ] || \
-	skip "Running Doxygen only for updates on 'master' branch (current: ${TRAVIS_BRANCH})."
-
-# check for job number
-# [ "${TRAVIS_JOB_NUMBER}" = "${TRAVIS_BUILD_NUMBER}.1" ] || \
-# 	skip "Running Doxygen only on first job of build ${TRAVIS_BUILD_NUMBER} (current: ${TRAVIS_JOB_NUMBER})."
-
-# install doxygen binary distribution
-doxygen_install()
-{
-	wget -O - "${DOXYGEN_URL}" | \
-		tar xz -C ${TMPDIR-/tmp} ${DOXYGEN_VER}/bin/doxygen
-    export PATH="${TMPDIR-/tmp}/${DOXYGEN_VER}/bin:$PATH"
-}
-
-doxygen_run()
-{
-	cd "${TRAVIS_BUILD_DIR}";
-	doxygen ${TRAVIS_BUILD_DIR}/build/doc/Doxyfile;
-	doxygen ${TRAVIS_BUILD_DIR}/build/doc/Doxyfile.zh-cn;
-}
-
-gh_pages_prepare()
-{
-	cd "${TRAVIS_BUILD_DIR}/build/doc";
-	[ ! -d "html" ] || \
-		abort "Doxygen target directory already exists."
-	git --version
-	git clone --single-branch -b gh-pages "${GITHUB_CLONE}" html
-	cd html
-	# setup git config (with defaults)
-	git config user.name "${GIT_NAME-travis}"
-	git config user.email "${GIT_EMAIL-"travis@localhost"}"
-	# clean working dir
-	rm -f .git/index
-	git clean -df
-}
-
-gh_pages_commit() {
-	cd "${TRAVIS_BUILD_DIR}/build/doc/html";
-	echo "rapidjson.org" > CNAME
-	git add --all;
-	git diff-index --quiet HEAD || git commit -m "Automatic doxygen build";
-}
-
-gh_setup_askpass() {
-	cat > ${GIT_ASKPASS} <<EOF
-#!/bin/bash
-echo
-exit 0
-EOF
-	chmod a+x "$GIT_ASKPASS"
-}
-
-gh_pages_push() {
-	# check for secure variables
-	[ "${TRAVIS_SECURE_ENV_VARS}" = "true" ] || \
-		skip "Secure variables not available, not updating GitHub pages."
-	# check for GitHub access token
-	[ "${GH_TOKEN+set}" = set ] || \
-		skip "GitHub access token not available, not updating GitHub pages."
-	[ "${#GH_TOKEN}" -eq 40 ] || \
-		abort "GitHub token invalid: found ${#GH_TOKEN} characters, expected 40."
-
-	cd "${TRAVIS_BUILD_DIR}/build/doc/html";
-	# setup credentials (hide in "set -x" mode)
-	git remote set-url --push origin "${GITHUB_URL}"
-	git config credential.helper 'store'
-	# ( set +x ; git config credential.username "${GH_TOKEN}" )
-	( set +x ; [ -f ${HOME}/.git-credentials ] || \
-			( echo "https://${GH_TOKEN}:@${GITHUB_HOST}" > ${HOME}/.git-credentials ; \
-			 chmod go-rw ${HOME}/.git-credentials ) )
-	# push to GitHub
-	git push origin gh-pages
-}
-
-doxygen_install
-gh_pages_prepare
-doxygen_run
-gh_pages_commit
-gh_pages_push
-

package/include/.clang-format

@@ -1,76 +0,0 @@
-BasedOnStyle: LLVM
-IndentWidth: 3
-UseTab: Never
-ColumnLimit: 120
-
---- 
-Language: Cpp
-# always align * and & to the type
-DerivePointerAlignment: false
-PointerAlignment: Left
-
-# regroup includes to these classes
-IncludeCategories:
-   - Regex: '(<|"(eosio)/)'
-     Priority: 4
-   - Regex: '(<|"(boost)/)'
-     Priority: 3
-   - Regex: '(<|"(llvm|llvm-c|clang|clang-c)/'
-     Priority: 3
-   - Regex: '<[[:alnum:]]+>'
-     Priority: 2
-   - Regex: '.*'
-     Priority: 1
-
-#IncludeBlocks: Regroup
-
-# set indent for public, private and protected
-#AccessModifierOffset: 3
-
-# make line continuations twice the normal indent
-ContinuationIndentWidth: 6
-
-# add missing namespace comments
-FixNamespaceComments: true
-
-# add spaces to braced list i.e. int* foo = { 0, 1, 2 }; instead of int* foo = {0,1,2};
-Cpp11BracedListStyle: false
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: true
-AlignConsecutiveDeclarations: true
-AlignOperands: true
-AlignTrailingComments: true
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: All
-AllowShortBlocksOnASingleLine: true
-#AllowShortIfStatementsOnASingleLine: WithoutElse
-#AllowShortIfStatementsOnASingleLine: true
-#AllowShortLambdasOnASingleLine: All
-AllowShortLoopsOnASingleLine: true
-AlwaysBreakTemplateDeclarations: true
-
-BinPackParameters: true
-### use this with clang9
-BreakBeforeBraces: Custom
-BraceWrapping:
-   #AfterCaseLabel: true
-   AfterClass: false
-   AfterControlStatement: false
-   AfterEnum: false
-   AfterFunction: false
-   AfterNamespace: false
-   AfterStruct: false
-   AfterUnion: false
-   AfterExternBlock: false
-   BeforeCatch: false
-   BeforeElse: false
-
-BreakConstructorInitializers: BeforeColon
-CompactNamespaces: true
-IndentCaseLabels: true
-IndentPPDirectives: AfterHash
-NamespaceIndentation: Inner
-ReflowComments: true
-SortIncludes: true
-SortUsingDeclarations: true
----

package/include/eosio/abi.hpp

@@ -1,286 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <string>
-#include <map>
-#include <vector>
-#include <variant>
-#include "types.hpp"
-#include "name.hpp"
-
-namespace eosio {
-
-enum class abi_error {
-   no_error,
-
-   recursion_limit_reached,
-   invalid_nesting,
-   unknown_type,
-   missing_name,
-   redefined_type,
-   base_not_a_struct,
-   extension_typedef,
-   bad_abi
-};
-
-constexpr inline std::string_view convert_abi_error(eosio::abi_error e) {
-   switch(e) {
-      case abi_error::no_error: return "No error";
-      case abi_error::recursion_limit_reached: return "Recursion limit reached";
-      case abi_error::invalid_nesting: return "Invalid nesting";
-      case abi_error::unknown_type: return "Unknown type";
-      case abi_error::missing_name: return "Missing name";
-      case abi_error::redefined_type: return "Redefined type";
-      case abi_error::base_not_a_struct: return "Base not a struct";
-      case abi_error::extension_typedef: return "Extension typedef";
-      case abi_error::bad_abi: return "Bad ABI";
-      default: return "internal failure";
-   };
-}
-
-struct abi_serializer;
-
-template <typename T>
-struct might_not_exist {
-    T value{};
-};
-
-template <typename T, typename S>
-void from_bin(might_not_exist<T>& obj, S& stream) {
-    if (stream.remaining())
-        return from_bin(obj.value, stream);
-}
-
-template <typename T, typename S>
-void from_json(might_not_exist<T>& obj, S& stream) {
-    return from_json(obj.value, stream);
-}
-
-using abi_extensions_type = std::vector<std::pair<uint16_t, std::vector<char>>>;
-
-struct type_def {
-    std::string new_type_name{};
-    std::string type{};
-};
-
-EOSIO_REFLECT(type_def, new_type_name, type);
-
-struct field_def {
-    std::string name{};
-    std::string type{};
-};
-
-EOSIO_REFLECT(field_def, name, type);
-
-struct struct_def {
-    std::string name{};
-    std::string base{};
-    std::vector<field_def> fields{};
-};
-
-EOSIO_REFLECT(struct_def, name, base, fields);
-
-struct action_def {
-    eosio::name name{};
-    std::string type{};
-    std::string ricardian_contract{};
-};
-
-EOSIO_REFLECT(action_def, name, type, ricardian_contract);
-
-struct table_def {
-    eosio::name name{};
-    std::string index_type{};
-    std::vector<std::string> key_names{};
-    std::vector<std::string> key_types{};
-    std::string type{};
-};
-
-EOSIO_REFLECT(table_def, name, index_type, key_names, key_types, type);
-
-struct clause_pair {
-    std::string id{};
-    std::string body{};
-};
-
-EOSIO_REFLECT(clause_pair, id, body);
-
-struct error_message {
-    uint64_t error_code{};
-    std::string error_msg{};
-};
-
-EOSIO_REFLECT(error_message, error_code, error_msg);
-
-struct variant_def {
-    std::string name{};
-    std::vector<std::string> types{};
-};
-
-EOSIO_REFLECT(variant_def, name, types);
-
-struct abi_def {
-    std::string version{};
-    std::vector<type_def> types{};
-    std::vector<struct_def> structs{};
-    std::vector<action_def> actions{};
-    std::vector<table_def> tables{};
-    std::vector<clause_pair> ricardian_clauses{};
-    std::vector<error_message> error_messages{};
-    abi_extensions_type abi_extensions{};
-    might_not_exist<std::vector<variant_def>> variants{};
-};
-
-EOSIO_REFLECT(abi_def, version, types, structs, actions, tables, ricardian_clauses, error_messages, abi_extensions,
-              variants);
-
-struct abi_type;
-
-struct abi_field {
-    std::string name;
-    const abi_type* type;
-};
-
-struct abi_type {
-    std::string name;
-
-    struct builtin {};
-    using alias_def = std::string;
-    struct alias { abi_type* type; };
-    struct optional { abi_type* type; };
-    struct extension { abi_type* type; };
-    struct array { abi_type* type; };
-    struct struct_ {
-        abi_type* base = nullptr;
-        std::vector<abi_field> fields;
-    };
-    using variant = std::vector<abi_field>;
-    std::variant<builtin, const alias_def*, const struct_def*, const variant_def*, alias, optional, extension, array, struct_, variant> _data;
-    const abi_serializer* ser = nullptr;
-
-    template<typename T>
-    abi_type(std::string name, T&& arg, const abi_serializer* ser)
-        : name(std::move(name)), _data(std::forward<T>(arg)), ser(ser) {}
-    abi_type(const abi_type&) = delete;
-    abi_type& operator=(const abi_type&) = delete;
-
-    // result<void> json_to_bin(std::vector<char>& bin, std::string_view json);
-    const abi_type* optional_of() const {
-       if(auto* t = std::get_if<optional>(&_data)) return t->type;
-       else return nullptr;
-    }
-    const abi_type* extension_of() const {
-       if(auto* t = std::get_if<extension>(&_data)) return t->type;
-       else return nullptr;
-    }
-    const abi_type* array_of() const {
-       if(auto* t = std::get_if<array>(&_data)) return t->type;
-       else return nullptr;
-    }
-    const struct_* as_struct() const {
-       return std::get_if<struct_>(&_data);
-    }
-    const variant* as_variant() const {
-       return std::get_if<variant>(&_data);
-    }
-
-    std::string bin_to_json(input_stream& bin, std::function<void()> f = []{}) const;
-    std::vector<char> json_to_bin(std::string_view json, std::function<void()> f = []{}) const;
-    std::vector<char> json_to_bin_reorderable(std::string_view json, std::function<void()> f = []{}) const;
-};
-
-struct abi {
-    std::map<eosio::name, std::string> action_types;
-    std::map<eosio::name, std::string> table_types;
-    std::map<std::string, abi_type> abi_types;
-    const abi_type* get_type(const std::string& name);
-
-    // Adds a type to the abi.  Has no effect if the type is already present.
-    // If the type is a struct, all members will be added recursively.
-    // Exception Safety: basic. If add_type fails, some objects may have
-    // an incomplete list of fields.
-    template<typename T>
-    abi_type* add_type();
-};
-
-void convert(const abi_def& def, abi&);
-void convert(const abi& def, abi_def&);
-
-extern const abi_serializer* const object_abi_serializer;
-extern const abi_serializer* const variant_abi_serializer;
-extern const abi_serializer* const array_abi_serializer;
-extern const abi_serializer* const extension_abi_serializer;
-extern const abi_serializer* const optional_abi_serializer;
-
-template<typename T>
-auto add_type(abi& a, T*) -> std::enable_if_t<reflection::has_for_each_field_v<T>, abi_type*> {
-   std::string name = get_type_name((T*)nullptr);
-   auto [iter, inserted] = a.abi_types.try_emplace(name, name, abi_type::struct_{}, object_abi_serializer);
-   if(!inserted)
-      return &iter->second;
-   auto& s = std::get<abi_type::struct_>(iter->second._data);
-   for_each_field<T>([&](const char* name, auto&& member){
-      auto member_type = a.add_type<std::decay_t<decltype(member((T*)nullptr))>>();
-      s.fields.push_back({name, member_type});
-   });
-   return &iter->second;
-}
-
-template<typename T>
-auto add_type(abi& a, T* t) -> std::enable_if_t<!reflection::has_for_each_field_v<T>, abi_type*> {
-   auto iter = a.abi_types.find(get_type_name(t));
-   check( iter != a.abi_types.end(),
-      convert_abi_error(abi_error::unknown_type) );
-   return &iter->second;
-}
-
-template<typename T>
-abi_type* add_type(abi& a, std::vector<T>*) {
-   auto element_type = a.add_type<T>();
-   check(!(element_type->optional_of() || element_type->array_of() || element_type->extension_of()),
-      convert_abi_error(abi_error::invalid_nesting));
-   std::string name = get_type_name((std::vector<T>*)nullptr);
-   auto [iter, inserted] = a.abi_types.try_emplace(name, name, abi_type::array{element_type}, array_abi_serializer);
-   return &iter->second;
-}
-
-template<typename... T>
-abi_type* add_type(abi& a, std::variant<T...>*) {
-   abi_type::variant types;
-   ([&](auto* t) {
-      auto type = add_type(a, t);
-      types.push_back({type->name, type});
-   }((T*)nullptr), ...);
-   std::string name = get_type_name((std::variant<T...>*)nullptr);
-
-   auto [iter, inserted] = a.abi_types.try_emplace(name, name, std::move(types), variant_abi_serializer);
-   return &iter->second;
-}
-
-template<typename T>
-abi_type* add_type(abi& a, std::optional<T>*) {
-   auto element_type = a.add_type<T>();
-   check(!(element_type->optional_of() || element_type->array_of() || element_type->extension_of()),
-      convert_abi_error(abi_error::invalid_nesting));
-   std::string name = get_type_name((std::optional<T>*)nullptr);
-   auto [iter, inserted] = a.abi_types.try_emplace(name, name, abi_type::optional{element_type}, optional_abi_serializer);
-   return &iter->second;
-}
-
-template<typename T>
-abi_type* add_type(abi& a, might_not_exist<T>*) {
-   auto element_type = a.add_type<T>();
-   check(!element_type->extension_of(),
-      convert_abi_error(abi_error::invalid_nesting));
-   std::string name = element_type->name + "$";
-   auto [iter, inserted] = a.abi_types.try_emplace(name, name, abi_type::extension{element_type}, extension_abi_serializer);
-   return &iter->second;
-}
-
-template<typename T>
-abi_type* abi::add_type() {
-   using eosio::add_type;
-   return add_type(*this, (T*)nullptr);
-}
-
-}