AsyncAccessControl.h

Go to the documentation of this file.

// Copyright 2014 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_AsyncAccessControl_h_GUID_4255BCEE_826C_4DB4_9368_9457ADBF9456
#define INCLUDED_AsyncAccessControl_h_GUID_4255BCEE_826C_4DB4_9368_9457ADBF9456

// Internal Includes
// - none

// Library/third-party includes
#include <boost/noncopyable.hpp>
#include <boost/thread.hpp>
#include <boost/optional/optional.hpp>

// Standard includes
// - none

namespace osvr {
namespace connection {
    class AsyncAccessControl : boost::noncopyable {
      public:
        AsyncAccessControl();

        bool mainThreadCTS();

        bool mainThreadDeny();

        bool mainThreadDenyPermanently();

      private:
        enum MainThreadMessages {
            MTM_WAIT,
            MTM_CLEAR_TO_SEND,
            MTM_DENY_SEND,
        };

        typedef boost::recursive_mutex MainMutexType;
        typedef boost::unique_lock<MainMutexType> MainLockType;
        MainMutexType m_mut;

        bool m_handleRTS(MainLockType &lock, MainThreadMessages response,
                         MainThreadMessages postCompletionState = MTM_WAIT);

        typedef boost::mutex DoneMutexType;
        typedef boost::unique_lock<DoneMutexType> DoneLockType;
        DoneMutexType m_mutDone;

        boost::optional<boost::thread::id> m_currentRequestThread;

        boost::condition_variable m_condMainThread;
        boost::condition_variable_any m_condAsyncThread;

        volatile bool m_rts;
        volatile bool m_done;
        volatile MainThreadMessages m_mainMessage;

        friend class RequestToSend;
    };

    class RequestToSend : boost::noncopyable {
      public:
        RequestToSend(AsyncAccessControl &aac);

        ~RequestToSend();

        bool request();

        bool isNested() const { return m_nested; }

      private:
        AsyncAccessControl::MainLockType m_lock;

        AsyncAccessControl::DoneLockType m_lockDone;

        bool m_calledRequest;

        bool m_nested;

        AsyncAccessControl &m_control;
        volatile bool &m_sharedRts;
        volatile bool &m_sharedDone;
        volatile AsyncAccessControl::MainThreadMessages &m_mainMessage;

        boost::condition_variable &m_condMainThread;
        boost::condition_variable_any &m_condAsyncThread;
    };
} // namespace connection
} // namespace osvr

#endif // INCLUDED_AsyncAccessControl_h_GUID_4255BCEE_826C_4DB4_9368_9457ADBF9456