init

Author: jstzwj

.gitignore

@@ -348,3 +348,6 @@ MigrationBackup/
 
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
+
+
+.vscode/

CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8.12)
+project(tpl)
+
+if (MSVC_VERSION GREATER_EQUAL "1900")
+    include(CheckCXXCompilerFlag)
+    CHECK_CXX_COMPILER_FLAG("/std:c++latest" _cpp_latest_flag_supported)
+    if (_cpp_latest_flag_supported)
+        add_compile_options("/std:c++latest")
+    endif()
+endif()
+
+add_subdirectory(example)

example/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(${PROJECT_SOURCE_DIR}/include)
+
+add_executable(demo ${PROJECT_SOURCE_DIR}/example/demo.cpp)

example/demo.cpp

@@ -0,0 +1,49 @@
+#include <tpl/tpltasks.hpp>
+#include <ppltasks.h>
+#include <iostream>
+#include <string>
+#include <memory>
+
+tpl::task<std::string> write_to_string()
+{
+    // Create a shared pointer to a string that is  
+    // assigned to and read by multiple tasks. 
+    // By using a shared pointer, the string outlives 
+    // the tasks, which can run in the background after 
+    // this function exits.
+    auto s = std::make_shared<std::string>("Value 1");
+
+    return tpl::create_task([s]
+        {
+            // Print the current value.
+            std::cout << "Current value: " << *s << std::endl;
+            // Assign to a new value.
+            *s = "Value 2";
+            return *s;
+        });
+    /*
+    .then([s]
+        {
+            // Print the current value.
+            std::cout << "Current value: " << *s << std::endl;
+            // Assign to a new value and return the string.
+            *s = "Value 3";
+            return *s;
+        });
+    */
+}
+
+int main()
+{
+    // Create a chain of tasks that work with a string.
+    auto t = write_to_string();
+
+    // Wait for the tasks to finish and print the result.
+    std::cout << "Final value: " << t.get() << std::endl;
+}
+
+/* Output:
+    Current value: Value 1
+    Current value: Value 2
+    Final value: Value 3
+*/

include/tpl/tpltasks.hpp

@@ -0,0 +1,163 @@
+#ifndef TPL_TASKS_H_
+#define TPL_TASKS_H_
+
+#include <stdexcept>
+#include <memory>
+#include <type_traits>
+
+namespace tpl
+{
+    enum task_status
+    {
+        /// <summary>
+        ///     The tasks queued to the <c>task_group</c> object have not completed.  Note that this value is not presently returned by
+        ///     the Concurrency Runtime.
+        /// </summary>
+        not_complete,
+
+        /// <summary>
+        ///     The tasks queued to the <c>task_group</c> or <c>structured_task_group</c> object completed successfully.
+        /// </summary>
+        completed,
+
+        /// <summary>
+        ///     The <c>task_group</c> or <c>structured_task_group</c> object was canceled.  One or more tasks may not have executed.
+        /// </summary>
+        canceled
+    };
+
+    class cancellation_token
+    {
+    public:
+
+    };
+
+    struct task_impl_base
+    {
+        enum TaskInternalState
+        {
+            // Tracks the state of the task, rather than the task collection on which the task is scheduled
+            Created,
+            Started,
+            PendingCancel,
+            Completed,
+            Canceled
+        };
+
+        task_impl_base()
+        {
+        }
+
+        virtual ~task_impl_base()
+        {
+        }
+
+        task_status wait()
+        {
+            
+        }
+
+    };
+
+    template<typename ReturnType>
+    struct task_impl : public task_impl_base
+    {
+
+    };
+
+    template<typename ReturnType>
+    struct task_ptr
+    {
+        typedef std::shared_ptr<task_impl<ReturnType>> PtrType;
+        /*
+        static PtrType make(CancellationTokenState * ct, scheduler_ptr scheduler_arg)
+        {
+            return std::make_shared<task_impl<ReturnType>>(ct, scheduler_arg);
+        }
+        */
+    };
+
+    template<typename ReturnType>
+    class task
+    {
+    public:
+        task() : impl_(nullptr)
+        {
+        }
+
+        task(const task& other) : impl_(other.impl_) {}
+
+        task(task&& other): impl_(std::move(other.impl_)) {}
+
+        task& operator=(const task& other)
+        {
+            if (this != &other)
+            {
+                impl_ = other.impl_;
+            }
+            return *this;
+        }
+
+        task& operator=(task&& other)
+        {
+            if (this != &other)
+            {
+                impl_ = std::move(other.impl_);
+            }
+            return *this;
+        }
+
+        template<typename FunctionType>
+        task(FunctionType fn)
+        {
+
+        }
+
+        task_status wait()
+        {
+            if (impl_)
+            {
+                return impl_.wait();
+            }
+            else
+            {
+                throw std::runtime_error("Task implement no found");
+            }
+        }
+
+        ReturnType get()
+        {
+            return ReturnType{};
+        }
+
+        typename task_ptr<ReturnType>::PtrType impl_;
+    };
+
+    template<typename ReturnType>
+    task<ReturnType> create_task(const task<ReturnType>& t)
+    {
+        task<ReturnType> created_task(t);
+        return created_task;
+    }
+
+    namespace details
+    {
+        template<typename ParamType>
+        struct TaskTypeFromParam
+        {
+#if __cplusplus <= 201103L
+            typedef std::result_of<ParamType> type;
+#else
+            typedef std::invoke_result<ParamType> type;
+#endif
+        };
+    }
+
+    template<typename ParamType>
+    task<typename details::TaskTypeFromParam<ParamType>::type> create_task(ParamType param) // , task_options _TaskOptions = task_options())
+    {
+        return task<typename details::TaskTypeFromParam<ParamType>::type>();
+    }
+}
+
+#endif // TPL_TASKS_H_