unblock | annoyance free , better open internet | Privacy library

You can use CROSS APPLY to retrieve the last action_id by timestamp and then apply a filter.

That's a bug. The problem is we set the retry topic name to the topics property of the endpoint, instead of setting it to the topicPartition. So we end up with two listeners for the main endpoint and none for the retry topic.

If you can please open an issue: https://github.com/spring-projects/spring-kafka/issues

Not sure there's a workaround for this using topic partitions - it should be fixed in the 2.8.5 release in a couple of weeks.

Thanks for reporting.

From what I can see your useNavigationBlockerController hook handleNavigationBlocking memoized callback is missing a dependency on the location.pathname value. In other words, it is closing over and referencing a stale value.

Add the missing dependencies:

1.You can use invoke('text') to get the button name:

So your fundamental problem here is that inside the sink you will seize a dishwasher, then the dish goes into the delay (With the number of dishwashers seized) and once out of the delay it will release what ever dishwashers it seized... But during the time it is in the delay the situation might have changed and you actually wanted to seize a different number of dishwashers for that specific sink...

Your options are to either

1. Remove dishes from the delay, release the correct amount of dishwashers, return back into the delay and delay for the remainder of the time...

2. Implement your own logic.

I would go for option 2 as option 1 means that you develop a workaround for the block created by AnyLogic and you will end up not using the blocks the way they were designed, this is unfortunately the issue with blockification

So I would have a collection inside of a sink that shows the number of dishwashers currently assigned to this sink. Then whenever a new dish enters a sink we recalculate the number of dishwashers to assign (perhaps at every sink? ) and then make the correct assignment.

Here is an example with some sample code - I did not test it but you will have something similar

First, I think that your script has no issue.

From your error message of "Exception: Please select an active sheet first. duplicateAndOrganizeActiveSheet @ Code.gs:7", I thought that in your situation, the link of the container-bound script (I think that in this case, it's script editor.) and Google Spreadsheet might be broken. For example, when such a situation occurs, an error like Please select an active sheet first. occurs.

In this case, please close Google Spreadsheet and the script editor. And, please open Google Spreadsheet and open the script editor, and run duplicateAndOrganizeActiveSheet again.

If this solution couldn't resolve the issue of Please select an active sheet first., please create a new Google Spreadsheet, open the script editor of the created Google Spreadsheet, please copy and paste your script, and run the script again.

Yes, that is exactly it. notify_one/all simply provide the waiting thread a chance to check the value for change. If it remains the same, e.g. because a different thread has set the value back to its original value, the thread will remain blocking.

Note: A valid implementation for this code is to use a global array of mutexes and condition_variables. atomic variables are then mapped to these objects by their pointer via a hash function. That's why you get spurious wakeups. Some atomics share the same condition_variable.

Something like this:

You are using a named function when you add a listener in order to pass it as a parameter, also, you only pass the listener to be removed, which should be the second parameter, after you define the event from which you are removing the listener. However, that's not the right approach. Instead you should define your function separately, like

The conditional if (0 < ...) is a problem, but it's not the only problem.

The effects of release are stated to be:

Atomically execute counter += update. Then, unblocks any threads that are waiting for counter to be greater than zero.

Note the words "any threads". Plural. This means that, even if a particular update value happened to be 1, all of the threads blocked on this condition must be notified. So calling notify_one is wrong, unless the implementation of notify_one always unblocks all waiting threads. Which would be an... interesting implementation of that function.

Even if you change notify_one to notify_all, that doesn't fix the problem. The logic of the condition basically assumes that thread notification should only happen if all of the threads (logically) notified by a previous release have escaped from their acquire calls. The standard requires no such thing.