ar_classes.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2016 Immo Software
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o Redistributions in binary form must reproduce the above copyright notice, this
 *   list of conditions and the following disclaimer in the documentation and/or
 *   other materials provided with the distribution.
 *
 * o Neither the name of the copyright holder nor the names of its contributors may
 *   be used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#if !defined(_AR_CLASSES_H_)
#define _AR_CLASSES_H_

#include "ar_kernel.h"
#include <string.h>

#if defined(__cplusplus)

namespace Ar {

//------------------------------------------------------------------------------
// Classes
//------------------------------------------------------------------------------

class Thread : public _ar_thread
{
public:
    Thread() {}

    Thread(const char * name, ar_thread_entry_t entry, void * param, void * stack, unsigned stackSize, uint8_t priority, bool startImmediately=true)
    {
        init(name, entry, param, stack, stackSize, priority, startImmediately);
    }

    template <class T>
    Thread(const char * name, T * object, void (T::*entry)(), void * stack, unsigned stackSize, uint8_t priority, bool startImmediately=true)
    {
        init<T>(name, object, entry, stack, stackSize, priority, startImmediately);
    }

    Thread(const char * name, ar_thread_entry_t entry, void * param, unsigned stackSize, uint8_t priority, bool startImmediately=true)
    {
        init(name, entry, param, NULL, stackSize, priority, startImmediately);
    }

    template <class T>
    Thread(const char * name, T * object, void (T::*entry)(), unsigned stackSize, uint8_t priority, bool startImmediately=true)
    {
        init<T>(name, object, entry, NULL, stackSize, priority, startImmediately);
    }

    virtual ~Thread();


    ar_status_t init(const char * name, ar_thread_entry_t entry, void * param, void * stack, unsigned stackSize, uint8_t priority, bool startImmediately=true);

    template <class T>
    ar_status_t init(const char * name, T * object, void (T::*entry)(), void * stack, unsigned stackSize, uint8_t priority, bool startImmediately=true)
    {
        return initForMemberFunction(name, object, member_thread_entry<T>, &entry, sizeof(entry), stack, stackSize, priority, startImmediately);
    }

    const char * getName() const { return m_name; }


    void suspend() { ar_thread_suspend(this); }

    void resume() { ar_thread_resume(this); }

    ar_thread_state_t getState() const { return m_state; }

    static void sleep(unsigned milliseconds) { ar_thread_sleep(milliseconds); }

    static void sleepUntil(unsigned wakeup) { ar_thread_sleep_until(wakeup); }


    uint8_t getPriority() const { return m_priority; }

    ar_status_t setPriority(uint8_t priority) { return ar_thread_set_priority(this, priority); }


    uint32_t getLoad() { return ar_thread_get_load(this); }

    uint32_t getStackUsed() { return ar_thread_get_stack_used(this); }


    static Thread * getCurrent() { return static_cast<Thread *>(ar_thread_get_current()); }

protected:

    uint8_t * m_allocatedStack; 
    ar_thread_entry_t m_userEntry;  

    virtual void threadEntry(void * param);

    static void thread_entry(void * param);

    template <class T>
    static void member_thread_entry(void * param)
    {
        Thread * thread = getCurrent();
        T * obj = static_cast<T *>(param);
        void (T::*member)(void);
        uint32_t * storage = thread->m_stackBottom + 1; // Add 1 to skip over check value.
        memcpy((char*)&member, storage, sizeof(member));
        (obj->*member)();
    }

    ar_status_t initForMemberFunction(const char * name, void * object, ar_thread_entry_t entry, void * memberPointer, uint32_t memberPointerSize, void * stack, unsigned stackSize, uint8_t priority, bool startImmediately);

private:
    Thread(const Thread & other);

    Thread& operator=(const Thread & other);
};

template <uint32_t S>
class ThreadWithStack : public Thread
{
public:
    ThreadWithStack() {}

    ThreadWithStack(const char * name, ar_thread_entry_t entry, void * param, uint8_t priority, bool startImmediately=true)
    {
        Thread::init(name, entry, param, m_stack, S, priority, startImmediately);
    }

    template <class T>
    ThreadWithStack(const char * name, T * object, void (T::*entry)(), uint8_t priority, bool startImmediately=true)
    {
        Thread::init<T>(name, object, entry, m_stack, S, priority, startImmediately);
    }

    ar_status_t init(const char * name, ar_thread_entry_t entry, void * param, uint8_t priority, bool startImmediately=true)
    {
        return Thread::init(name, entry, param, m_stack, S, priority, startImmediately);
    }

    template <class T>
    ar_status_t init(const char * name, T * object, void (T::*entry)(), uint8_t priority, bool startImmediately=true)
    {
        return Thread::init<T>(name, object, entry, m_stack, S, priority, startImmediately);
    }

protected:
    uint8_t m_stack[S]; 

private:
    ThreadWithStack(const ThreadWithStack<S> & other);

    ThreadWithStack& operator=(const ThreadWithStack<S> & other);
};

class Semaphore : public _ar_semaphore
{
public:
    Semaphore() {}

    Semaphore(const char * name, unsigned count=1)
    {
        init(name, count);
    }

    ar_status_t init(const char * name, unsigned count=1) { return ar_semaphore_create(this, name, count); }

    ~Semaphore() { ar_semaphore_delete(this); }

    const char * getName() const { return m_name; }

    ar_status_t get(uint32_t timeout=kArInfiniteTimeout) { return ar_semaphore_get(this, timeout); }

    ar_status_t put() { return ar_semaphore_put(this); }

    unsigned getCount() const { return m_count; }

private:
    Semaphore(const Semaphore & other);

    Semaphore& operator=(const Semaphore & other);
};

class Mutex : public _ar_mutex
{
public:
    Mutex() {}

    Mutex(const char * name)
    {
        init(name);
    }

    ar_status_t init(const char * name) { return ar_mutex_create(this, name); }

    ~Mutex() { ar_mutex_delete(this); }

    const char * getName() const { return m_name; }

    ar_status_t get(uint32_t timeout=kArInfiniteTimeout) { return ar_mutex_get(this, timeout); }

    ar_status_t put() { return ar_mutex_put(this); }

    ar_thread_t * getOwner() { return (ar_thread_t *)m_owner; }

    bool isLocked() { return ar_mutex_is_locked(this); }

    class Guard
    {
    public:
        Guard(Mutex & mutex)
        :   m_mutex(mutex)
        {
            m_mutex.get(kArInfiniteTimeout);
        }

        ~Guard()
        {
            m_mutex.put();
        }

    protected:
        Mutex & m_mutex;  
    };

private:
    Mutex(const Mutex & other);

    Mutex& operator=(const Mutex & other);
};

class Channel : public _ar_channel
{
public:
    Channel() {}

    Channel(const char * name, uint32_t width=0) { init(name); }

    ~Channel() { ar_channel_delete(this); }

    ar_status_t init(const char * name, uint32_t width=0) { return ar_channel_create(this, name, width); }

    ar_status_t send(const void * value, uint32_t timeout=kArInfiniteTimeout) { return ar_channel_send(this, value, timeout); }

    ar_status_t receive(void * value, uint32_t timeout=kArInfiniteTimeout) { return ar_channel_receive(this, value, timeout); }

private:
    Channel(const Channel & other);

    Channel& operator=(const Channel & other);
};

template <typename T>
class TypedChannel : public Channel
{
public:
    TypedChannel() {}

    TypedChannel(const char * name) : Channel(name, sizeof(T)) {}

    ar_status_t init(const char * name) { return Channel::init(name, sizeof(T)); }

    ar_status_t send(const T & value, uint32_t timeout=kArInfiniteTimeout)
    {
        return Channel::send(&value, timeout);
    }

    T receive(uint32_t timeout=kArInfiniteTimeout)
    {
        T temp;
        Channel::receive(&temp, timeout);
        return temp;
    }

    ar_status_t receive(T & value, uint32_t timeout=kArInfiniteTimeout)
    {
        return Channel::receive(&value, timeout);
    }

    friend T& operator <<= (T& lhs, TypedChannel<T>& rhs)
    {
        lhs = rhs.receive();
        return lhs;
    }

    friend T& operator >> (T& lhs, TypedChannel<T>& rhs)
    {
        rhs.send(lhs);
        return lhs;
    }

private:
    TypedChannel(const TypedChannel<T> & other);

    TypedChannel& operator=(const TypedChannel<T> & other);
};

class Queue : public _ar_queue
{
public:
    Queue() {}

    Queue(const char * name, void * storage, unsigned elementSize, unsigned capacity)
    {
        init(name, storage, elementSize, capacity);
    }

    ar_status_t init(const char * name, void * storage, unsigned elementSize, unsigned capacity)
    {
        return ar_queue_create(this, name, storage, elementSize, capacity);
    }

    ~Queue() { ar_queue_delete(this); }

    const char * getName() const { return m_name; }

    ar_status_t send(const void * element, uint32_t timeout=kArInfiniteTimeout) { return ar_queue_send(this, element, timeout); }

    ar_status_t receive(void * element, uint32_t timeout=kArInfiniteTimeout) { return ar_queue_receive(this, element, timeout); }

    bool isEmpty() const { return m_count == 0; }

    unsigned getCount() const { return m_count; }

private:
    Queue(const Queue & other);

    Queue& operator=(const Queue & other);
};

template <typename T, unsigned N>
class StaticQueue : public Queue
{
public:
    StaticQueue() {}

    StaticQueue(const char * name)
    {
        Queue::init(name, m_storage, sizeof(T), N);
    }

    ar_status_t init(const char * name)
    {
        return Queue::init(name, m_storage, sizeof(T), N);
    }

    ar_status_t send(T element, uint32_t timeout=kArInfiniteTimeout)
    {
        return Queue::send((const void *)&element, timeout);
    }

    ar_status_t receive(T * element, uint32_t timeout=kArInfiniteTimeout)
    {
        return Queue::receive((void *)element, timeout);
    }

    T receive(uint32_t timeout=kArInfiniteTimeout, ar_status_t * resultStatus=NULL)
    {
        T element;
        ar_status_t status = Queue::receive((void *)&element, timeout);
        if (resultStatus)
        {
            *resultStatus = status;
        }
        return element;
    }

protected:
    T m_storage[N]; 

private:
    StaticQueue(const StaticQueue<T,N> & other);

    StaticQueue& operator=(const StaticQueue<T,N> & other);
};

class Timer : public _ar_timer
{
public:

    typedef void (*callback_t)(Timer * timer, void * param);

    Timer() {}

    Timer(const char * name, callback_t callback, void * param, ar_timer_mode_t timerMode, uint32_t delay)
    {
        init(name, callback, param, timerMode, delay);
    }

    ~Timer() { ar_timer_delete(this); }

    ar_status_t init(const char * name, callback_t callback, void * param, ar_timer_mode_t timerMode, uint32_t delay);

    const char * getName() const { return m_name; }

    void start() { ar_timer_start(this); }

    void stop() { ar_timer_stop(this); }

    bool isActive() const { return m_isActive; }

    void setDelay(uint32_t delay) { ar_timer_set_delay(this, delay); }

    uint32_t getDelay() const { return m_delay; }

protected:

    callback_t m_userCallback;    

    static void timer_wrapper(ar_timer_t * timer, void * arg);

private:
    Timer(const Timer & other);

    Timer& operator=(const Timer & other);
};

template <class T>
class TimerWithMemberCallback : public Timer
{
public:

    typedef void (T::*callback_t)(Timer * timer);

    TimerWithMemberCallback<T>() {}

    TimerWithMemberCallback<T>(const char * name, T * object, callback_t callback, ar_timer_mode_t timerMode, uint32_t delay)
    {
        init(name, object, callback, timerMode, delay);
    }

    ~TimerWithMemberCallback<T>() {}

    ar_status_t init(const char * name, T * object, callback_t callback, ar_timer_mode_t timerMode, uint32_t delay)
    {
        m_memberCallback = callback;
        return Timer::init(name, member_callback, object, timerMode, delay);
    }

protected:

    callback_t m_memberCallback;    

    void invoke(T * obj)
    {
        (obj->*m_memberCallback)(this);
    }

    static void member_callback(Timer * timer, void * param)
    {
        TimerWithMemberCallback<T> * _this = static_cast<TimerWithMemberCallback<T> *>(timer);
        T * obj = static_cast<T *>(param);
        _this->invoke(obj);
    }

private:
    TimerWithMemberCallback<T>(const TimerWithMemberCallback<T> & other);

    TimerWithMemberCallback<T>& operator=(const TimerWithMemberCallback<T> & other);
};

class RunLoop : public _ar_runloop
{
public:
    RunLoop() {}

    RunLoop(const char * name)
    {
        init(name);
    }

    ~RunLoop() { ar_runloop_delete(this); }

    ar_status_t init(const char * name) { return ar_runloop_create(this, name); }

    const char * getName() const { return m_name; }

    ar_status_t run(uint32_t timeout=kArInfiniteTimeout, ar_runloop_result_t * object=0) { return ar_runloop_run(this, timeout, object); }

    ar_status_t stop() { return ar_runloop_stop(this); }

    ar_status_t perform(ar_runloop_function_t function, void * param=0) { return ar_runloop_perform(this, function, param); }

    ar_status_t signal(uint32_t signal=0) { return ar_runloop_signal(this, signal); }

    ar_status_t addTimer(ar_timer_t * timer) { return ar_runloop_add_timer(this, timer); }

    ar_status_t addQueue(ar_queue_t * queue, ar_runloop_queue_handler_t callback=NULL, void * param=NULL) { return ar_runloop_add_queue(this, queue, callback, param); }

    static ar_runloop_t * getCurrent(void) { return ar_runloop_get_current(); }
};

} // namespace Ar

#endif // defined(__cplusplus)

#endif // _AR_CLASSES_H_
//------------------------------------------------------------------------------
// EOF
//------------------------------------------------------------------------------