request.h

/* $Id: request.h 2926 2013-02-05 19:07:32Z roma $ */

#include <map>

#include "../ipc/socket.h"
#include "logbook.h"

namespace ffl
{

        namespace cssc
        {

                class request
                {
                public:

                        request() throw(){}

                        request(ipc::socket& _s, long _t = -1) throw(...);

                        request(const std::string& _name) throw(...):Name(_name){}

                        ~request();

                        void reply(ipc::socket& _s, long _t = -1) throw(...);

                        void execute(ipc::socket& _s, logbook& _log, long _iotimeout = -1, long _rqtimeout = -1) throw(...);

                        class argument
                        {
                        public:

                                typedef std::map<std::string, argument*> set;

                                enum type
                                {
                                        NONE    = 0,
                                        TABLE,
                                };

                                argument(set& _s, const std::string& _n):Set(_s)
                                {
                                        It = _s.insert(std::pair<std::string, argument*>(_n, this)).first;
                                }

                                virtual ~argument(){}

                                virtual type typeof() throw() = 0;

                                void send(ipc::socket& _s, long _t) throw(...)
                                {
                                        _s.put(typeof(), _t);
                                        send_value(_s, _t);
                                }

                                static void send(ipc::socket& _s, const set& _v, long _t = -1) throw(...);

                                void receive(ipc::socket& _s, long _t) throw(...)
                                {
                                        receive_value(_s, _t);
                                }

                                static void receive(ipc::socket& _s, set& _v, long _t = -1) throw(...);

                                virtual argument* clone(set& _s) throw(...) = 0;

                                static void erase(set& _v) throw();

                        protected:

                                virtual void send_value(ipc::socket& _s, long _t) throw(...) = 0;

                                virtual void receive_value(ipc::socket& _s, long _t) throw(...) = 0;

                                set::iterator It;

                                set& Set;

                        };

                        class argument_of_table:public argument
                        {
                        public:

                                argument_of_table(set& _s, const std::string& _n):argument(_s, _n){}

                                argument_of_table(set& _s, const std::string& _n, const co_table& _t):argument(_s, _n)
                                {
                                        Value.copy(_t);
                                }

                                type typeof() throw(){return TABLE;}

                                co_table Value;

                                argument* clone(set& _s) throw(...)
                                {
                                        return new argument_of_table(_s, It->first, Value);
                                }

                        private:

                                class transfer:public co_table_transfer
                                {
                                public:

                                        transfer(ipc::socket& _s, long _timeout):Socket(_s), IOTimeout(_timeout){}

                                private:

                                        ipc::socket& Socket;

                                        long IOTimeout;

                                        void do_write(void *_buf, int _size)
                                        {
                                                Socket.write((const char*)_buf, _size, IOTimeout);
                                        }

                                        void do_read(void *_buf, int _size)
                                        {
                                                Socket.read((char*)_buf, _size, IOTimeout);
                                        }

                                };

                                void send_value(ipc::socket& _s, long _t) throw(...)
                                {
                                        Value.write(transfer(_s, _t));
                                }

                                void receive_value(ipc::socket& _s, long _t) throw(...)
                                {
                                        Value.read(transfer(_s, _t));
                                }

                        };

                        argument::set In;

                        argument::set Out;

                        std::string Name;       

                protected:

                        virtual void just_begin() throw(){}

                        virtual void just_ended() throw(){}

                        virtual bool checkpoint() throw(){return true;} 

                };

        }

}