WindowsAsyncService.cpp

#include "WindowsAsyncService.h"

namespace

{

namespace

presentation

{

namespace

windows

{

using

namespace

collections

;

/*********************************************************************** WindowsAsyncService::TaskItem ***********************************************************************/

WindowsAsyncService

TaskItem

() :semaphore(

) { }

WindowsAsyncService

TaskItem

(

Semaphore

_semaphore

const

Func

void

()>&

_proc

) :semaphore(

_semaphore

) ,proc(

_proc

) { }

WindowsAsyncService

TaskItem

() { }

/*********************************************************************** WindowsAsyncService::DelayItem ***********************************************************************/

WindowsAsyncService

DelayItem

(

WindowsAsyncService

_service

const

Func

void

()>&

_proc

bool

_executeInMainThread

vint

milliseconds

) :service(

_service

) ,proc(

_proc

) ,status(

INativeDelay

Pending

) ,executeTime(

DateTime

LocalTime

().

Forward

(

milliseconds

)) ,executeInMainThread(

_executeInMainThread

) { }

WindowsAsyncService

DelayItem

() { }

INativeDelay

ExecuteStatus

WindowsAsyncService

DelayItem

GetStatus

() {

return

status

; }

bool

WindowsAsyncService

DelayItem

Delay

(

vint

milliseconds

) {

SPIN_LOCK(service->taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

service

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

(

status

INativeDelay

Pending

) {

executeTime

DateTime

LocalTime

().

Forward

(

milliseconds

);

return

true

; } }

return

false

; }

bool

WindowsAsyncService

DelayItem

Cancel

() {

SPIN_LOCK(service->taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

service

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

(

status

INativeDelay

Pending

) {

(

service

delayItems

Remove

(

this

)) {

status

INativeDelay

Canceled

;

return

true

; } } }

return

false

; }

/*********************************************************************** WindowsAsyncService ***********************************************************************/

WindowsAsyncService

() :mainThreadId(

Thread

GetCurrentThreadId

()) { }

WindowsAsyncService

() { }

void

WindowsAsyncService

ExecuteAsyncTasks

() {

DateTime

now

DateTime

LocalTime

();

Array

TaskItem

items

;

List

Ptr

DelayItem

executableDelayItems

;

SPIN_LOCK(taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

CopyFrom

(

items

taskItems

);

taskItems

RemoveRange

(

items

Count

());

for

(

vint

delayItems

Count

()-

;

--) {

Ptr

DelayItem

item

delayItems

[

];

(

now

filetime

item

executeTime

filetime

) {

item

status

INativeDelay

Executing

;

executableDelayItems

Add

(

item

);

delayItems

RemoveAt

(

); } } }

FOREACH(TaskItem, item, items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

TaskItem

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

TaskItem

item

;

__foreach_iterator__

(

item

);)

{

item

proc

(

);

(

item

semaphore

) {

item

semaphore

Release

(); } }

FOREACH(Ptr<DelayItem>, item, executableDelayItems)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

DelayItem

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

executableDelayItems

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

DelayItem

item

;

__foreach_iterator__

(

item

);)

{

(

item

executeInMainThread

) {

item

proc

(

);

item

status

INativeDelay

Executed

; }

else

{

InvokeAsync

([=]() {

item

proc

(

);

item

status

INativeDelay

Executed

; }); } } }

bool

WindowsAsyncService

IsInMainThread

(

INativeWindow

window

) {

return

Thread

GetCurrentThreadId

()==

mainThreadId

; }

void

WindowsAsyncService

InvokeAsync

(

const

Func

void

()>&

proc

) {

ThreadPoolLite

Queue

(

proc

); }

void

WindowsAsyncService

InvokeInMainThread

(

INativeWindow

window

const

Func

void

()>&

proc

) {

SPIN_LOCK(taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

TaskItem

item

(

proc

);

taskItems

Add

(

item

); } }

bool

WindowsAsyncService

InvokeInMainThreadAndWait

(

INativeWindow

window

const

Func

void

()>&

proc

vint

milliseconds

) {

Semaphore

semaphore

;

semaphore

Create

(

);

SPIN_LOCK(taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

TaskItem

item

semaphore

proc

);

taskItems

Add

(

item

); }

(

milliseconds

) {

return

semaphore

Wait

(); }

else

{

return

semaphore

WaitForTime

(

milliseconds

); } }

Ptr

INativeDelay

WindowsAsyncService

DelayExecute

(

const

Func

void

()>&

proc

vint

milliseconds

) {

Ptr

DelayItem

delay

;

SPIN_LOCK(taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

delay

new

DelayItem

(

this

proc

false

milliseconds

);

delayItems

Add

(

delay

); }

return

delay

; }

Ptr

INativeDelay

WindowsAsyncService

DelayExecuteInMainThread

(

const

Func

void

()>&

proc

vint

milliseconds

) {

Ptr

DelayItem

delay

;

SPIN_LOCK(taskListLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

taskListLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

delay

new

DelayItem

(

this

proc

true

milliseconds

);

delayItems

Add

(

delay

); }

return

delay

; } } } }