Imported Upstream version 6.6.0.89

Former-commit-id: b39a328747c2f3414dc52e009fb6f0aa80ca2492

external/api-doc-tools/mdoc/mdoc.Test/UwpTestWinRtComponentCpp/Class1.cpp

@@ -0,0 +1,166 @@
+#include "pch.h"
+#include "Class1.h"
+
+#include <ppltasks.h>
+#include <concurrent_vector.h>
+
+using namespace concurrency;
+using namespace Platform::Collections;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::Foundation;
+using namespace Windows::UI::Core;
+
+using namespace UwpTestWinRtComponentCpp;
+using namespace Platform;
+
+Class1::Class1()
+{
+
+}
+
+//Public API
+IVector<double>^ Class1::ComputeResult(double input)
+{
+	// Implement your function in ISO C++ or
+	// call into your C++ lib or DLL here. This example uses AMP.
+	float numbers[] = { 1.0, 10.0, 60.0, 100.0, 600.0, 10000.0 };
+	array_view<float, 1> logs(6, numbers);
+
+	// See http://msdn.microsoft.com/en-us/library/hh305254.aspx
+	parallel_for_each(
+		logs.extent,
+		[=](index<1> idx) restrict(amp)
+	{
+		logs[idx] = concurrency::fast_math::log10(logs[idx]);
+	}
+	);
+
+	// Return a Windows Runtime-compatible type across the ABI
+	auto res = ref new Vector<double>();
+	int len = safe_cast<int>(logs.extent.size());
+	for (int i = 0; i < len; i++)
+	{
+		res->Append(logs[i]);
+	}
+
+	// res is implicitly cast to IVector<double>
+	return res;
+}
+
+// Determines whether the input value is prime.
+bool Class1::is_prime(int n)
+{
+	if (n < 2)
+		return false;
+	for (int i = 2; i < n; ++i)
+	{
+		if ((n % i) == 0)
+			return false;
+	}
+	return true;
+}
+
+// This method computes all primes, orders them, then returns the ordered results.
+IAsyncOperationWithProgress<IVector<int>^, double>^ Class1::GetPrimesOrdered(int first, int last)
+{
+	return create_async([this, first, last]
+	(progress_reporter<double> reporter) -> IVector<int>^ {
+		// Ensure that the input values are in range.
+		if (first < 0 || last < 0) {
+			throw ref new InvalidArgumentException();
+		}
+		// Perform the computation in parallel.
+		concurrent_vector<int> primes;
+		long operation = 0;
+		long range = last - first + 1;
+		double lastPercent = 0.0;
+
+		parallel_for(first, last + 1, [this, &primes, &operation,
+			range, &lastPercent, reporter](int n) {
+
+			// Increment and store the number of times the parallel
+			// loop has been called on all threads combined. There
+			// is a performance cost to maintaining a count, and
+			// passing the delegate back to the UI thread, but it's
+			// necessary if we want to display a determinate progress
+			// bar that goes from 0 to 100%. We can avoid the cost by
+			// setting the ProgressBar IsDeterminate property to false
+			// or by using a ProgressRing.
+			if (InterlockedIncrement(&operation) % 100 == 0)
+			{
+				reporter.report(100.0 * operation / range);
+			}
+
+			// If the value is prime, add it to the local vector.
+			if (is_prime(n)) {
+				primes.push_back(n);
+			}
+		});
+
+		// Sort the results.
+		std::sort(begin(primes), end(primes), std::less<int>());
+		reporter.report(100.0);
+
+		// Copy the results to a Vector object, which is
+		// implicitly converted to the IVector return type. IVector
+		// makes collections of data available to other
+		// Windows Runtime components.
+		return ref new Vector<int>(primes.begin(), primes.end());
+	});
+}
+
+// This method returns no value. Instead, it fires an event each time a
+// prime is found, and passes the prime through the event.
+// It also passes progress info.
+IAsyncActionWithProgress<double>^ Class1::GetPrimesUnordered(int first, int last)
+{
+
+	auto window = Windows::UI::Core::CoreWindow::GetForCurrentThread();
+	m_dispatcher = window->Dispatcher;
+
+
+	return create_async([this, first, last](progress_reporter<double> reporter) {
+
+		// Ensure that the input values are in range.
+		if (first < 0 || last < 0) {
+			throw ref new InvalidArgumentException();
+		}
+
+		// In this particular example, we don't actually use this to store
+		// results since we pass results one at a time directly back to
+		// UI as they are found. However, we have to provide this variable
+		// as a parameter to parallel_for.
+		concurrent_vector<int> primes;
+		long operation = 0;
+		long range = last - first + 1;
+		double lastPercent = 0.0;
+
+		// Perform the computation in parallel.
+		parallel_for(first, last + 1,
+			[this, &primes, &operation, range, &lastPercent, reporter](int n)
+		{
+			// Store the number of times the parallel loop has been called  
+			// on all threads combined. See comment in previous method.
+			if (InterlockedIncrement(&operation) % 100 == 0)
+			{
+				reporter.report(100.0 * operation / range);
+			}
+
+			// If the value is prime, pass it immediately to the UI thread.
+			if (is_prime(n))
+			{
+				// Since this code is probably running on a worker
+				// thread, and we are passing the data back to the
+				// UI thread, we have to use a CoreDispatcher object.
+				m_dispatcher->RunAsync(CoreDispatcherPriority::Normal,
+					ref new DispatchedHandler([this, n, operation, range]()
+				{
+					this->primeFoundEvent(n);
+
+				}, Platform::CallbackContext::Any));
+
+			}
+		});
+		reporter.report(100.0);
+	});
+}