/home/fwph/code/wurde/rde/core/WritableType.H

Go to the documentation of this file.

#ifndef WRITABLETYPE_H
#define WRITABLETYPE_H

// $Id: WritableType.H 68 2007-02-01 17:56:57Z fwph $

/* for a logger */
//#include <Logger.H>
#include <string>
#include <RobotTypes.H>

namespace WURDE {
       
        template <class Type>
        class Writable {
              
        public:
                Writable();
                explicit Writable(Type _value);
                Writable(Type _value, ConsumeMode _cmode);
                Writable(Type _value, WriteMode _rwmode, std::string id);
                Writable(Type _value, ConsumeMode _cmode, WriteMode _rwmode, std::string id);
              
                bool setValue(Type _value);
              
                Type getValue() const;
              
              
                bool setRWMode(WriteMode _mode);
                WriteMode getRWMode() const;
              
              
                bool setCMode(ConsumeMode _mode);
                ConsumeMode getCMode() const;
              
                bool setStatus(StatusMode stat);
              
                StatusMode getStatus() const;
              
                bool setLock();
              
                bool setValueAndLock(Type _value){if(!setValue(_value)){return false;} return setLock();};
              
                bool unlock();
              
                bool locked() const;
              
                std::string getLockOwner() const;
              
                void COM_ADAPTOR_setValue(Type _value);
              
              
                void COM_ADAPTOR_setRWMode(WriteMode _mode);
              
                void COM_ADAPTOR_setStatus(StatusMode stat);
              
              
                void COM_ADAPTOR_setLockOwner(std::string owner);
              
                Writable& operator=(const Writable& r) {
                        m_value=r.m_value;
                        m_rwMode=r.m_rwMode;
                        m_cMode=r.m_cMode;
                        m_sMode=r.m_sMode;
                        m_id=r.m_id;
                        m_lockOwner=r.m_lockOwner;                   
                        return *this;
                }

        protected: 
                Type m_value;
                WriteMode m_rwMode;
                ConsumeMode m_cMode;
                StatusMode m_sMode;
                std::string m_id;
                std::string m_lockOwner;
              
        };
       
        template <class Type>
        Writable<Type>::Writable(Type _value, ConsumeMode _cmode, WriteMode _rwmode, std::string id){
                m_value=_value;
                m_cMode=_cmode;
                m_rwMode=_rwmode;
                m_id=id;
                if(_rwmode==W_LOCKED){
                        m_lockOwner=m_id;
                }else{
                        m_lockOwner="";
                }
        }
       
        template <class Type>
        Writable<Type>::Writable(Type _value, ConsumeMode _cmode){
                Writable(_value,_cmode,W_ALL,"Default");
        }
       
       
        template <class Type>
        Writable<Type>::Writable(Type _value, WriteMode _rwmode, std::string id){
                Writable(_value,C_CONSUMER,_rwmode,id);
        }
       
        template <class Type>
        Writable<Type>::Writable(Type _value){
                Writable(_value,C_CONSUMER,W_ALL,"Default");
        }
       
       
        template <class Type>
        Writable<Type>::Writable(){
                m_cMode=C_CONSUMER;
                m_rwMode=W_ALL;
                m_id="Default";
                m_lockOwner="";
        }
       
        template <class Type>
        bool Writable<Type>::setValue(Type _value){
                switch (m_rwMode){
                case W_SUPPLIER_ONLY: 
                        if(m_cMode==C_SUPPLIER){
                                m_sMode=STAT_OKAY;
                                m_value=_value;
                                break;
                        }else{
                                //g_warn("Consumer tried to set a supplier-only value");
                                return false;
                        }
                case W_CONSUMER_ONLY:
                        if(m_cMode==C_CONSUMER){
                                m_sMode=STAT_REQUEST;
                                m_value=_value;
                                break;
                        }else{
                                // g_warn("Supplier tried to set a consumer-only value");
                                return false;
                        }
                case W_ALL:
                        if(m_cMode==C_CONSUMER){
                                m_sMode=STAT_REQUEST;
                        }else{
                                m_sMode=STAT_OKAY;
                        }
                        m_value=_value;
                        break;
                case W_LOCKED:
                        if(m_id==m_lockOwner){
                                m_value=_value;
                                break;
                                if(m_cMode==C_CONSUMER){
                                        m_sMode=STAT_REQUEST;
                                }else{
                                        m_sMode=STAT_NULL;
                                }
                        }
                        //g_warn("Attempted to set a locked value, doesn't hold lock");
                        return false;
                case W_NULL:
                default:
                        //       g_error("Writable value has improper writeMode setting. THIS IS A BUG.");
                        return false;
                }
              
                return true;
        }
       
        template <class Type>
        Type Writable<Type>::getValue() const{
                return m_value;
        }
       
        template <class Type>
        bool Writable<Type>::setRWMode(WriteMode rwmode){
              
                /* you must EXPLICITLY use setLock or unLock to modify the read/write state of a locked variable */
                if(rwmode==W_LOCKED||m_rwMode==W_LOCKED){
                        //g_error("Attempted to change the LOCKED status of a Writable value using setRWMode. THIS IS A BUG");
                        return false;
                }
              
                switch(rwmode){
                case W_SUPPLIER_ONLY:
                        if(m_cMode==C_SUPPLIER){
                                m_rwMode=rwmode;
                                break;
                        }
                        return false;
                case W_CONSUMER_ONLY:
                        if(m_cMode==C_CONSUMER){
                                m_rwMode=rwmode;
                                break;
                        }
                        return false;
                case W_ALL:
                        m_rwMode=rwmode;
                        break;
                case W_LOCKED:
                case W_NULL:
                default:
                        //             g_error("Writable value has improper mode setting. THIS IS A BUG");
                        return false;
                }
              
                return true;
              
        }
       
       
        template <class Type>
        WriteMode Writable<Type>::getRWMode() const{
                return m_rwMode;
        }
       
        template <class Type>
        bool Writable<Type>::setCMode(ConsumeMode _mode){
                m_cMode=_mode;
                return true;
        }
       
        template <class Type>
        ConsumeMode Writable<Type>::getCMode() const{
                return m_cMode;
        }
       
        template <class Type>
        bool Writable<Type>::setStatus(StatusMode stat){
                if(m_cMode==C_SUPPLIER){
                        m_sMode=stat;
                        return true;
                }
              
                //        g_error("Consumer attempted to set the status of a Writable value. THIS IS A BUG.");
                return false;
        }
       
        template <class Type>
        StatusMode Writable<Type>::getStatus() const{
                return m_sMode;
        }
       
        template <class Type>
        bool Writable<Type>::setLock(){
                switch (m_rwMode){
                case W_SUPPLIER_ONLY:
                        if(m_cMode==C_SUPPLIER){
                                m_rwMode=W_LOCKED;
                                m_lockOwner=m_id;
                                break;
                        }
                        //   g_warn("Consumer attempted to lock a value set to SUPPLIER_ONLY");
                        return false;
                case W_CONSUMER_ONLY:
                        if(m_cMode==C_CONSUMER){
                                m_rwMode=W_LOCKED;
                                m_lockOwner=m_id;
                                break;
                        }
                        //             g_warn("Supplier attempted to lock a value set to CONSUMER_ONLY");
                        return false;
                case W_ALL:
                        m_rwMode=W_LOCKED;
                        m_lockOwner=m_id;
                        break;
                case W_LOCKED:
                        //             g_warn("Attempted to lock an already locked Writable value");
                        return false;
                case W_NULL:
                default:
                        //g_error("Writable value has improper read/write setting. THIS IS A BUG.");
                        return false;
                }
                return true;
        }
       
        template <class Type>
        bool Writable<Type>::unlock(){
                if(m_rwMode!=W_LOCKED){
                        //             g_warn("Attempted to unlock a Writable value which was not locked");
                        return false;
                }
              
                if(m_lockOwner!=m_id){
                        // g_warn("Non-owner attempted to unlock a Writable value.");
                        return false;
                }
              
                m_lockOwner="";
                m_rwMode=W_ALL;
                return true;
              
        }
       
        template <class Type>
        bool Writable<Type>::locked() const{
                if (m_rwMode==W_LOCKED)
                        return true;
              
                return false;
        }
       
       
        template <class Type>
        std::string Writable<Type>::getLockOwner() const{
                return m_lockOwner;
        }
       
       
        template <class Type>
        void Writable<Type>::COM_ADAPTOR_setValue(Type _value){
                m_value=_value;
        }
        
        template <class Type>
        void Writable<Type>::COM_ADAPTOR_setRWMode(WriteMode _mode){
                m_rwMode=_mode;
        }
        
        template <class Type>
        void Writable<Type>::COM_ADAPTOR_setStatus(StatusMode stat){
                m_sMode=stat;
        }
       
        template <class Type>
        void Writable<Type>::COM_ADAPTOR_setLockOwner(std::string owner){
                m_lockOwner=owner;
        }
       
};

#endif

---