Can be more Platform Abstraction?

[Singa17]

I am started using this stack for my project and found its started working as expected. I am having little bit challenges as follow

My Project builds on C++ 17.

1. I have my own mutex. If i enable multithread by default #include <shared_mutex> is enabled. Now i have to change the stack code point my mutex. Can we do something here? Can this mutex to be moved to platform?

2. Also i have my own Socket manager to send or receive. and i use both TLS and non TLS. I Can manage with MQTTOnlyBSDSocket = 0 to point my socket manager. is it possible to move the mbedtls to platform? so that this code will look clean :-)

3. I get compiler error that "warning C4200: nonstandard extension used: zero-sized array in struct/union".

           struct BinaryData
            {
                /** The data length in bytes */
                uint16 length;
                uint8  data[];

                /** Call this method to read the structure when it's casted from the network buffer */
                void swapNetwork() { length = BigEndian(length); }
            };

            /** A MQTT string is basically a string with a BigEndian size going first (section 1.5.4) */
            struct String
            {
                /** The string length in bytes */
                uint16 length;
                char   data[];

                /** Call this method to read the structure when it's casted from the network buffer */
                void swapNetwork() { length = BigEndian(length); }
            };

[X-Ryl669]

In this project, the main header aren't linked in any way with the platform, only the implementation (.cpp) file are.

Replying point by point:

1. If you don't have a shared_mutex header in your C++ library, you can create one containing this code (not tested):

struct shared_mutex {
    std::atomic<int> refcount{0};
    void lock()
    {
        int val = 0;
        while (!refcount.compare_exchange_weak(val, -1, std::memory_order_acquire))
            val = 0; // We only CAS if val is 0, that is: no reader
    }

    void unlock() { refcount.store(0, std::memory_order_release); }
    void lock_shared() 
    { int val;
        do {
                int counter = 0;
                constexpr int relaxation_time = 35000; // Set to whatever is long enough for your platform
                while(true) {
                    val = refcount.load(std::memory_order_relaxed);
                    if (val != -1) break;
                    if (++counter == relaxation_time) { sched_yield(); counter = 0; // Or anything to relinquish the thread timeslice to the scheduler }
               }
        } while (!refcount.compare_exchange_weak(val, val+1, std::memory_order_acquire));
    }

    void unlock_shared() { refcount.fetch_sub(1, std::memory_order_relaxed); }
};

Or, simply remove the whole mutex altogether (don't define MQTTMultithread) and protect the MQTTClient with a plain old standard mutex in your code, if more than one thread is used to access the client.

2. Look at MQTTc.cpp in test folder. There's an example code that not using the BSDSocket code (instead it's using a cross platform implementation that depends on OpenSSL IIRC). In that case, you'll implement the interface that's described in this file
3. You can delete both class, they aren't used in the library anymore, it's a leftover from version 1.0 code.