Mission Impossible / How to create datatypes which cannot contain invalid state

// {
 
class SerialPort {
public:
    void        connect();
    std::string send_request(const std::string& request);
    void        print_state(std::ostream& os) const;
 
private:
    mutable std::mutex guard_;
    bool               is_connected_ = false;
    bool               is_sending_   = false;
    bool               is_receiving_ = false;
};
 
void SerialPort::connect() {
    long_running_task();
 
    std::scoped_lock lock{guard_};
    BOOST_ASSERT_MSG(not is_connected_, "port already connected yet");
    is_connected_ = true;
}
 
std::string SerialPort::send_request(const std::string& request) {
    {
        std::scoped_lock lock{guard_};
        BOOST_ASSERT_MSG(is_connected_, "port not connected yet");
        BOOST_ASSERT_MSG(not is_sending_, "detected race");
        BOOST_ASSERT_MSG(not is_receiving_, "detected race");
        is_sending_ = true;
    }
    long_running_task();
    {
        std::scoped_lock lock{guard_};
        BOOST_ASSERT_MSG(is_connected_, "detected race");
        BOOST_ASSERT_MSG(is_sending_, "detected race");
        BOOST_ASSERT_MSG(not is_receiving_, "detected race");
        is_sending_   = false;
        is_receiving_ = true;
    }
    long_running_task();
    {

The problem here is, that we have three bool variables which would result in possible state combinations, of which only are used:

is_connected	is_sending	is_receiving
false	ignored	ignored
true	false	false
true	false	true
true	true	false

This leads to the following results:

A person which reads the code has to look up all the various asserts in order to understand the existing invariants
A person which debuggs the code has to keep values of supposedly relevant variables in his head, which are actually not used
It is very easy for a different programmer to change the code in such a way that the previous invariant is no longer given