InControl.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef _InControl_
#define _InControl_

#include <string>
#include <list>
#include <typeinfo>
#include <sstream>
#include "TypeInfo.hxx"
#include "InControlBase.hxx"
#include "OutControlBase.hxx"

namespace CLAM {
        class Processing;
        class OutControlBase;

        template<class ControlDataType>
        class OutControl;

        template<class ControlDataType>
        class InControl : public InControlBase
        {
                class Callback;
        private:
                Callback * _callback;
        protected:
                ControlDataType mLastValue;
                
        public:
                InControl(const std::string &name = "unnamed in control", Processing * proc = 0)
                        : InControlBase(name,proc)
                        , _callback(new NullCallback)
                {
                }
                template <typename ProcessingType, typename ParameterType>
                InControl(const std::string &name, ProcessingType * proc, void (ProcessingType::*callback)(const ParameterType&))
                        : InControlBase(name,proc)
                        , _callback(new MethodCallback<ProcessingType,ParameterType>(proc, callback))
                {
                }
                template <typename ProcessingType, typename ParameterType>
                InControl(unsigned id, const std::string &name, ProcessingType * proc, void (ProcessingType::*callback)(unsigned, const ParameterType&))
                        : InControlBase(name,proc)
                        , _callback(new MethodCallbackWithId<ProcessingType,ParameterType>(proc, callback, id))
                {
                }
                template <typename ProcessingType, typename ParameterType>
                InControl(const std::string &name, ProcessingType * proc, void (ProcessingType::*callback)(ParameterType))
                        : InControlBase(name,proc)
                        , _callback(new MethodCallbackByCopy<ProcessingType,ParameterType>(proc, callback))
                {
                }
                template <typename ProcessingType, typename ParameterType>
                InControl(unsigned id, const std::string &name, ProcessingType * proc, void (ProcessingType::*callback)(unsigned, ParameterType))
                        : InControlBase(name,proc)
                        , _callback(new MethodCallbackByCopyWithId<ProcessingType,ParameterType>(proc, callback, id))
                {
                }


                virtual ~InControl()
                {
                        delete _callback;
                }

                virtual void DoControl(const ControlDataType& val) 
                {
                        mLastValue = val;
                        _hasBeenRead=false;
                        _callback->DoControl(val);
                };

                virtual const ControlDataType& GetLastValue() const 
                {
                        _hasBeenRead=true;
                        return mLastValue; 
                };
                const std::string GetLastValueAsString() // TODO: Use plugins as soon we start to use non streamable types
                {
                        return GetLastValueAsString((TokenIsStorableAsLeaf*)0);
                }
                // For the typed linking check
                virtual const std::type_info& GetTypeId() const { return typeid(ControlDataType); };
        private:
                std::string GetLastValueAsString(StaticFalse* /*isStreamable*/) const
                {
                        return "Not printable";
                }
                std::string GetLastValueAsString(StaticTrue* /*isStreamable*/) const
                {
                        std::ostringstream valueStream;
                        valueStream << GetLastValue();
                        return valueStream.str();
                }

        private:
                // Callback wrappers

                typedef typename TypeInfo<ControlDataType>::StorableAsLeaf TokenIsStorableAsLeaf;
                class Callback
                {
                        public:
                                virtual ~Callback() {}
                                virtual void DoControl(const ControlDataType & val) =0;
                };

                class NullCallback : public Callback
                {
                        public:
                                virtual void DoControl(const ControlDataType & val) {}
                };

                template <typename ProcessingType, typename ValueParameterType>
                class MethodCallback : public Callback
                {
                protected:
                        ProcessingType * _processing;
                        void (ProcessingType::*_method)(const ValueParameterType& );
                public:
                        MethodCallback(ProcessingType * processing, void (ProcessingType::*method)(const ValueParameterType &) )
                                : _processing(processing)
                                , _method(method)
                        {
                        }
                        virtual void DoControl(const ControlDataType & value)
                        {
                                (_processing->*_method)(value);
                        }
                };

                template <typename ProcessingType, typename ValueParameterType>
                class MethodCallbackWithId : public Callback
                {
                        ProcessingType * _processing;
                        void (ProcessingType::*_method)(unsigned, const ValueParameterType &);
                        unsigned _id;
                public:
                        MethodCallbackWithId(ProcessingType * processing, void (ProcessingType::*method)(unsigned,const ValueParameterType &), unsigned id )
                                : _processing(processing)
                                , _method(method)
                                , _id(id)
                        {
                        }
                        virtual void DoControl(const ControlDataType & value)
                        {
                                (_processing->*_method)(_id, value);
                        }
                };

                template <typename ProcessingType, typename ValueParameterType>
                class MethodCallbackByCopy : public Callback
                {
                protected:
                        ProcessingType * _processing;
                        void (ProcessingType::*_method)(ValueParameterType);
                public:
                        MethodCallbackByCopy(ProcessingType * processing, void (ProcessingType::*method)(ValueParameterType) )
                                : _processing(processing)
                                , _method(method)
                        {
                        }
                        virtual void DoControl(const ControlDataType & value)
                        {
                                (_processing->*_method)(value);
                        }
                };

                template <typename ProcessingType, typename ValueParameterType>
                class MethodCallbackByCopyWithId : public Callback
                {
                        ProcessingType * _processing;
                        void (ProcessingType::*_method)(unsigned, ValueParameterType);
                        unsigned _id;
                public:
                        MethodCallbackByCopyWithId(ProcessingType * processing, void (ProcessingType::*method)(unsigned,ValueParameterType), unsigned id )
                                : _processing(processing)
                                , _method(method)
                                , _id(id)
                        {
                        }
                        virtual void DoControl(const ControlDataType & value)
                        {
                                (_processing->*_method)(_id, value);
                        }
                };
        };
        
typedef InControl<float> FloatInControl;

} // End namespace CLAM
#endif //_InControl_