C++ reimplementation of Python's threading.Event
You can simplify things using RAII.
bool isSet () {
    isSetLock.lock ();
    bool isSetRet (isSet_);
    isSetLock.unlock ();
    return isSetRet;
};

Can be simplified to:
bool isSet () {
    std::lock_guard&lt;std::mutex&gt;  lockGuard(isSetLock);    // Calls lock.
    return isSet_;
};                                                        // Calls unlock
                                                          // in destructor.

Why do you have two different mutexes? There should only be a single one:
void wait () {
    if (!isSet ()) {
        std::unique_lock &lt;std::mutex&gt; setTriggerUniqueLock (setTriggerLock);
        setTrigger.wait (setTriggerUniqueLock);
    }
}

This should be:
    std::unique_lock &lt;std::mutex&gt; setTriggerUniqueLock(isSetLock);
    while (isSet()) {
       setTrigger.wait(setTriggerUniqueLock);
    }

Note: While the thread is paused (waiting) in the condition variable the mutex is unlocked (so other threads can still lock the mutex). The thread is only released from the condition variable (after a notify) when it has re-acquired the lock.
Note: You have to use while here (not if). After the thread is woken you need to retest the condition because another thread may have re-locked the isSet_ variable before this thread re-acquired the lock.
Note: The condition variable has this built in:
    std::unique_lock &lt;std::mutex&gt; setTriggerUniqueLock(isSetLock);
    setTrigger.wait(setTriggerUniqueLock, [&amp;](){return !isSet_WithoutNeedingToLockAsWeHaveTheLock()});

Note: After doing this your notify_all() should be on setTrigger.