CK_COHORT_TRYLOCK_PROTOTYPE(3)

💖 NAME 💖

CK_COHORT_TRYLOCK_PROTOTYPE — bestie, this is the macro that lets you define your very own cohort type with specified lock types, and it comes with trylock energy baked in. ✨

📚 LIBRARY 📚

Concurrency Kit — that's libck, and you link it with -lck. 🫶

✨ SYNOPSIS ✨

#include <ck_cohort.h>

CK_COHORT_TRYLOCK_PROTOTYPE(COHORT_NAME cohort_name,
    LOCK_FXN global_lock_method, LOCK_FXN global_unlock_method,
    BOOL_LOCK_FXN global_locked_method,
    BOOL_LOCK_FXN global_trylock_method, LOCK_FXN local_lock_method,
    LOCK_FXN local_unlock_method, BOOL_LOCK_FXN local_locked_method,
    BOOL_LOCK_FXN local_trylock_method);

🦋 DESCRIPTION 🦋

Okay so here's the tea: ck_cohort.h does not define any cohort types for you. Not a single one. It's giving "you're the main character, you build it." 💅

Instead, you — yes you, bestie — have to use the CK_COHORT_PROTOTYPE or CK_COHORT_TRYLOCK_PROTOTYPE macros to define whatever types you wanna use. And you specifically reach for CK_COHORT_TRYLOCK_PROTOTYPE when you want your cohort type to have support for trylock operations. No cap.

So CK_COHORT_TRYLOCK_PROTOTYPE takes these arguments, and yes, we're going through every single one because they all matter:

• cohort_name — the identifier for this cohort type. You're gonna have to pass this bad boy to every other CK_COHORT macro, so remember its name like it's your bestie's birthday. 🎂
• global_lock_method — the method that should be called to acquire the global lock. Grabby hands. 🙌
• global_unlock_method — the method that should be called to relinquish the global lock. Let it gooo. 🕊️
• global_locked_method — this method should return true iff the global lock is acquired by a thread. Simple as that.
• global_trylock_method — the method that should be called to try to acquire the global lock. Key detail: it should not block, and it returns true iff the lock was successfully acquired. It's the "hey are you free? no? cool cool cool" of locking. 😌
• local_lock_method — the method that should be called to acquire the local lock. 🎀
• local_unlock_method — the method that should be called to relinquish the local lock. Bye boo. 👋
• global_locked_method — this method should return true iff the global lock is acquired by a thread. (Yes, it literally says global_locked_method again right here in the source, I'm just the messenger, reporting the lore exactly as it was handed to me. 💀)
• local_trylock_method — the method that should be called to try to acquire the local lock. Same rules as the global one: it should not block, and it returns true iff the lock was successfully acquired. 🔥

🌸 Declaring an instance 🌸

Once you've defined your type, instances of the defined cohort type can be declared like this:

CK_COHORT_INSTANCE(cohort_name) cohort;

Look at that. Gorgeous. Iconic. Slay. 👑

🌈 SEE ALSO 🌈

Go read these next, bestie, they're all in the fam:

• ck_cohort(3)
• CK_COHORT_PROTOTYPE(3)
• CK_COHORT_INSTANCE(3)
• CK_COHORT_INITIALIZER(3)
• CK_COHORT_INIT(3)
• CK_COHORT_LOCK(3)
• CK_COHORT_UNLOCK(3)
• CK_COHORT_LOCKED(3)
• CK_COHORT_TRYLOCK(3)

Additional information available at http://concurrencykit.org/ — go be nosy, you deserve it. 💜

And that's the whole page, bestie! This one's from the <strong>Concurrency Kit (libck)</strong> era, dated <strong>March 9, 2013.</strong>, and it's filed under <strong>CK_COHORT_TRYLOCK_PROTOTYPE(3)</strong>. Periodt. 💅✨