ray-cpp 2.54.0__py3-none-win_amd64.whl

ray/cpp/example/_.bazelrc

@@ -0,0 +1,2 @@
+build --cxxopt="-std=c++17"
+build --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0"

ray/cpp/example/_BUILD.bazel

@@ -0,0 +1,41 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
+
+cc_binary(
+    name = "example",
+    srcs = glob([
+        "*.cc",
+    ]),
+    data = [
+        "example.so",
+    ],
+    linkstatic = True,
+    deps = [
+        ":ray_api",
+    ],
+)
+
+cc_binary(
+    name = "example.so",
+    srcs = glob([
+        "*.cc",
+    ]),
+    linkopts = ["-shared"],
+    linkstatic = True,
+    deps = [
+        ":ray_api",
+    ],
+)
+
+cc_library(
+    name = "ray_api",
+    srcs = [
+        "thirdparty/lib/libray_api.so",
+    ],
+    hdrs = glob([
+        "thirdparty/include/**/*.h",
+        "thirdparty/include/**/*.hpp",
+    ]),
+    linkopts = ["-Wl,-rpath,./"],
+    strip_include_prefix = "thirdparty/include",
+    visibility = ["//visibility:public"],
+)

ray/cpp/example/example.cc

@@ -0,0 +1,59 @@
+/// This is an example of Ray C++ application. Please visit
+/// `https://docs.ray.io/en/master/ray-core/walkthrough.html#installation`
+/// for more details.
+
+/// including the `<ray/api.h>` header
+#include <ray/api.h>
+
+/// common function
+int Plus(int x, int y) { return x + y; }
+/// Declare remote function
+RAY_REMOTE(Plus);
+
+/// class
+class Counter {
+ public:
+  int count;
+
+  Counter(int init) { count = init; }
+  /// static factory method
+  static Counter *FactoryCreate(int init) { return new Counter(init); }
+
+  /// non static function
+  int Add(int x) {
+    count += x;
+    return count;
+  }
+};
+/// Declare remote function
+RAY_REMOTE(Counter::FactoryCreate, &Counter::Add);
+
+int main(int argc, char **argv) {
+  /// initialization
+  ray::Init();
+
+  /// put and get object
+  auto object = ray::Put(100);
+  auto put_get_result = *(ray::Get(object));
+  std::cout << "put_get_result = " << put_get_result << std::endl;
+
+  /// common task
+  auto task_object = ray::Task(Plus).Remote(1, 2);
+  int task_result = *(ray::Get(task_object));
+  std::cout << "task_result = " << task_result << std::endl;
+
+  /// actor
+  ray::ActorHandle<Counter> actor = ray::Actor(Counter::FactoryCreate).Remote(0);
+  /// actor task
+  auto actor_object = actor.Task(&Counter::Add).Remote(3);
+  int actor_task_result = *(ray::Get(actor_object));
+  std::cout << "actor_task_result = " << actor_task_result << std::endl;
+  /// actor task with reference argument
+  auto actor_object2 = actor.Task(&Counter::Add).Remote(task_object);
+  int actor_task_result2 = *(ray::Get(actor_object2));
+  std::cout << "actor_task_result2 = " << actor_task_result2 << std::endl;
+
+  /// shutdown
+  ray::Shutdown();
+  return 0;
+}

ray/cpp/example/run.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+#Cause the script to exit if a single command fails.
+set -e
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE:-$0}")" || exit; pwd)"
+
+bazel --nosystem_rc --nohome_rc build //:example
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    DYLD_LIBRARY_PATH="$ROOT_DIR/thirdparty/lib" "${ROOT_DIR}"/bazel-bin/example
+else
+    LD_LIBRARY_PATH="$ROOT_DIR/thirdparty/lib" "${ROOT_DIR}"/bazel-bin/example
+fi

ray/cpp/include/boost/align.hpp

@@ -0,0 +1,22 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_HPP
+#define BOOST_ALIGN_HPP
+
+#include <boost/align/align.hpp>
+#include <boost/align/align_down.hpp>
+#include <boost/align/align_up.hpp>
+#include <boost/align/aligned_alloc.hpp>
+#include <boost/align/aligned_allocator.hpp>
+#include <boost/align/aligned_allocator_adaptor.hpp>
+#include <boost/align/aligned_delete.hpp>
+#include <boost/align/alignment_of.hpp>
+#include <boost/align/assume_aligned.hpp>
+#include <boost/align/is_aligned.hpp>
+
+#endif

ray/cpp/include/boost/aligned_storage.hpp

@@ -0,0 +1,18 @@
+//-----------------------------------------------------------------------------
+// boost aligned_storage.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ALIGNED_STORAGE_HPP
+#define BOOST_ALIGNED_STORAGE_HPP
+
+#include <boost/type_traits/aligned_storage.hpp>
+
+#endif // BOOST_ALIGNED_STORAGE_HPP

ray/cpp/include/boost/any.hpp

@@ -0,0 +1,344 @@
+// See http://www.boost.org/libs/any for Documentation.
+
+#ifndef BOOST_ANY_INCLUDED
+#define BOOST_ANY_INCLUDED
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+// what:  variant type boost::any
+// who:   contributed by Kevlin Henney,
+//        with features contributed and bugs found by
+//        Antony Polukhin, Ed Brey, Mark Rodgers,
+//        Peter Dimov, and James Curran
+// when:  July 2001, April 2013 - 2020
+
+#include <boost/any/bad_any_cast.hpp>
+#include <boost/any/fwd.hpp>
+#include <boost/type_index.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/conditional.hpp>
+
+namespace boost
+{
+    class any
+    {
+    public: // structors
+
+        BOOST_CONSTEXPR any() BOOST_NOEXCEPT
+          : content(0)
+        {
+        }
+
+        template<typename ValueType>
+        any(const ValueType & value)
+          : content(new holder<
+                BOOST_DEDUCED_TYPENAME remove_cv<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>::type
+            >(value))
+        {
+            BOOST_STATIC_ASSERT_MSG(
+                !anys::detail::is_basic_any<ValueType>::value,
+                "boost::any shall not be constructed from boost::anys::basic_any"
+            );
+        }
+
+        any(const any & other)
+          : content(other.content ? other.content->clone() : 0)
+        {
+        }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+        // Move constructor
+        any(any&& other) BOOST_NOEXCEPT
+          : content(other.content)
+        {
+            other.content = 0;
+        }
+
+        // Perfect forwarding of ValueType
+        template<typename ValueType>
+        any(ValueType&& value
+            , typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0 // disable if value has type `any&`
+            , typename boost::disable_if<boost::is_const<ValueType> >::type* = 0) // disable if value has type `const ValueType&&`
+          : content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value)))
+        {
+            BOOST_STATIC_ASSERT_MSG(
+                !anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value,
+                "boost::any shall not be constructed from boost::anys::basic_any"
+            );
+        }
+#endif
+
+        ~any() BOOST_NOEXCEPT
+        {
+            delete content;
+        }
+
+    public: // modifiers
+
+        any & swap(any & rhs) BOOST_NOEXCEPT
+        {
+            placeholder* tmp = content;
+            content = rhs.content;
+            rhs.content = tmp;
+            return *this;
+        }
+
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+        template<typename ValueType>
+        any & operator=(const ValueType & rhs)
+        {
+            BOOST_STATIC_ASSERT_MSG(
+                !anys::detail::is_basic_any<ValueType>::value,
+                "boost::anys::basic_any shall not be assigned into boost::any"
+            );
+            any(rhs).swap(*this);
+            return *this;
+        }
+
+        any & operator=(any rhs)
+        {
+            rhs.swap(*this);
+            return *this;
+        }
+
+#else
+        any & operator=(const any& rhs)
+        {
+            any(rhs).swap(*this);
+            return *this;
+        }
+
+        // move assignment
+        any & operator=(any&& rhs) BOOST_NOEXCEPT
+        {
+            rhs.swap(*this);
+            any().swap(rhs);
+            return *this;
+        }
+
+        // Perfect forwarding of ValueType
+        template <class ValueType>
+        any & operator=(ValueType&& rhs)
+        {
+            BOOST_STATIC_ASSERT_MSG(
+                !anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value,
+                "boost::anys::basic_any shall not be assigned into boost::any"
+            );
+            any(static_cast<ValueType&&>(rhs)).swap(*this);
+            return *this;
+        }
+#endif
+
+    public: // queries
+
+        bool empty() const BOOST_NOEXCEPT
+        {
+            return !content;
+        }
+
+        void clear() BOOST_NOEXCEPT
+        {
+            any().swap(*this);
+        }
+
+        const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
+        {
+            return content ? content->type() : boost::typeindex::type_id<void>().type_info();
+        }
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    private: // types
+#else
+    public: // types (public so any_cast can be non-friend)
+#endif
+
+        class BOOST_SYMBOL_VISIBLE placeholder
+        {
+        public: // structors
+
+            virtual ~placeholder()
+            {
+            }
+
+        public: // queries
+
+            virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT = 0;
+
+            virtual placeholder * clone() const = 0;
+
+        };
+
+        template<typename ValueType>
+        class holder
+#ifndef BOOST_NO_CXX11_FINAL
+          final
+#endif
+          : public placeholder
+        {
+        public: // structors
+
+            holder(const ValueType & value)
+              : held(value)
+            {
+            }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+            holder(ValueType&& value)
+              : held(static_cast< ValueType&& >(value))
+            {
+            }
+#endif
+        public: // queries
+
+            const boost::typeindex::type_info& type() const BOOST_NOEXCEPT BOOST_OVERRIDE
+            {
+                return boost::typeindex::type_id<ValueType>().type_info();
+            }
+
+            placeholder * clone() const BOOST_OVERRIDE
+            {
+                return new holder(held);
+            }
+
+        public: // representation
+
+            ValueType held;
+
+        private: // intentionally left unimplemented
+            holder & operator=(const holder &);
+        };
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+    private: // representation
+
+        template<typename ValueType>
+        friend ValueType * any_cast(any *) BOOST_NOEXCEPT;
+
+        template<typename ValueType>
+        friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT;
+
+#else
+
+    public: // representation (public so any_cast can be non-friend)
+
+#endif
+
+        placeholder * content;
+
+    };
+
+    inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT
+    {
+        lhs.swap(rhs);
+    }
+
+    template<typename ValueType>
+    ValueType * any_cast(any * operand) BOOST_NOEXCEPT
+    {
+        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
+            ? boost::addressof(
+                static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held
+              )
+            : 0;
+    }
+
+    template<typename ValueType>
+    inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT
+    {
+        return any_cast<ValueType>(const_cast<any *>(operand));
+    }
+
+    template<typename ValueType>
+    ValueType any_cast(any & operand)
+    {
+        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
+
+
+        nonref * result = any_cast<nonref>(boost::addressof(operand));
+        if(!result)
+            boost::throw_exception(bad_any_cast());
+
+        // Attempt to avoid construction of a temporary object in cases when
+        // `ValueType` is not a reference. Example:
+        // `static_cast<std::string>(*result);`
+        // which is equal to `std::string(*result);`
+        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            boost::is_reference<ValueType>::value,
+            ValueType,
+            BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type
+        >::type ref_type;
+
+#ifdef BOOST_MSVC
+#   pragma warning(push)
+#   pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local!
+#endif
+        return static_cast<ref_type>(*result);
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
+    }
+
+    template<typename ValueType>
+    inline ValueType any_cast(const any & operand)
+    {
+        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
+        return any_cast<const nonref &>(const_cast<any &>(operand));
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template<typename ValueType>
+    inline ValueType any_cast(any&& operand)
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/
+            || boost::is_const< typename boost::remove_reference<ValueType>::type >::value,
+            "boost::any_cast shall not be used for getting nonconst references to temporary objects"
+        );
+        return any_cast<ValueType>(operand);
+    }
+#endif
+
+
+    // Note: The "unsafe" versions of any_cast are not part of the
+    // public interface and may be removed at any time. They are
+    // required where we know what type is stored in the any and can't
+    // use typeid() comparison, e.g., when our types may travel across
+    // different shared libraries.
+    template<typename ValueType>
+    inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT
+    {
+        return boost::addressof(
+            static_cast<any::holder<ValueType> *>(operand->content)->held
+        );
+    }
+
+    template<typename ValueType>
+    inline const ValueType * unsafe_any_cast(const any * operand) BOOST_NOEXCEPT
+    {
+        return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
+    }
+}
+
+// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+// Copyright Antony Polukhin, 2013-2022.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#endif

ray/cpp/include/boost/archive/archive_exception.hpp

@@ -0,0 +1,100 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive/archive_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <exception>
+#include <boost/assert.hpp>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/decl.hpp>
+
+// note: the only reason this is in here is that windows header
+// includes #define exception_code _exception_code (arrrgghhhh!).
+// the most expedient way to address this is be sure that this
+// header is always included whenever this header file is included.
+#if defined(BOOST_WINDOWS)
+#include <excpt.h>
+#endif
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by archives
+//
+class BOOST_SYMBOL_VISIBLE archive_exception :
+    public virtual std::exception
+{
+private:
+    char m_buffer[128];
+protected:
+    BOOST_ARCHIVE_DECL unsigned int
+    append(unsigned int l, const char * a);
+    BOOST_ARCHIVE_DECL
+    archive_exception() BOOST_NOEXCEPT;
+public:
+    typedef enum {
+        no_exception,       // initialized without code
+        other_exception,    // any exception not listed below
+        unregistered_class, // attempt to serialize a pointer of
+                            // an unregistered class
+        invalid_signature,  // first line of archive does not contain
+                            // expected string
+        unsupported_version,// archive created with library version
+                            // subsequent to this one
+        pointer_conflict,   // an attempt has been made to directly
+                            // serialize an object which has
+                            // already been serialized through a pointer.
+                            // Were this permitted, the archive load would result
+                            // in the creation of an extra copy of the object.
+        incompatible_native_format, // attempt to read native binary format
+                            // on incompatible platform
+        array_size_too_short,// array being loaded doesn't fit in array allocated
+        input_stream_error, // error on input stream
+        invalid_class_name, // class name greater than the maximum permitted.
+                            // most likely a corrupted archive or an attempt
+                            // to insert virus via buffer overrun method.
+        unregistered_cast,   // base - derived relationship not registered with
+                            // void_cast_register
+        unsupported_class_version, // type saved with a version # greater than the
+                            // one used by the program.  This indicates that the program
+                            // needs to be rebuilt.
+        multiple_code_instantiation, // code for implementing serialization for some
+                            // type has been instantiated in more than one module.
+        output_stream_error // error on input stream
+    } exception_code;
+    exception_code code;
+
+    BOOST_ARCHIVE_DECL archive_exception(
+        exception_code c,
+        const char * e1 = NULL,
+        const char * e2 = NULL
+    ) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
+    BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
+};
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP