MicoleAgent.h

Go to the documentation of this file.

/*
 * This file is part of Micole Architecture
 *
 * Copyright (C) 2007 Micole partners
 *
 * Micole Architecture is free software: you can redistribute it 
 * and/or modify it under the terms of the GNU Lesser General 
 * Public License as published by the Free Software Foundation, 
 * either version 3 of the License, or (at your option) any 
 * later version.
 *
 * Micole Architecture 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 Lesser General Public License for more 
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Micole Architecture.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef MicoleAgent_H
#define MicoleAgent_H
#include <micolelib.h>

#include <iostream>
#include <string>
#include <vector>
using namespace std;

#include "Binding.h"
#include "MicoleBus.h"

enum AgentState {ACTIVE, SUSPENDED, UNKNOWN, UNACTIVE };//Agent states
namespace AgentModuleConstants {

        //Message prefixes
        const static char * PHANTOM = "^Phantom:(.*)";
        const static char * SOUND = "^Sound:(.*)";
        const static char * OUTPUT = "^Output:(.*)";
        const static char * PHANTOM_INPUT = "^Phantom_input:(*.)";
        const static char * MAGELLAN_INPUT = "^Magellan_input:(.*)";
        const static char * KEYBOARD_INPUT = "^Keyboard_input:(.*)";

        const static char * QUIT = "^Quit$";
        const static char * PING = "^Ping$";
        const static char * SUSPEND = "^Suspend:(.*)";
        const static char * RESUME ="^Resume:(.*)";

        const static char * LOCALHOST = "127.0.0.1";
        const static char * MULTICAST = "127.255.255.255";

        
        //Direct message types. Types start from 100. 
        const static int REGISTER_REPLY = 100;
        const static int SUSPEND_REQUEST = 101;
}


class MICOLELIB_API MicoleAgent
{
        friend class SuspendMsgListener;
        friend class RegisterMsgListener;

        public:
                virtual ~MicoleAgent();
                string getAgentName();
                string getAgentType();
                void onApplicationConnected( MicoleBus *app );
                void onApplicationDisconnected( MicoleBus *app );

                //MicoleBus *app is the sender of the message.
                void handlePingMessage( MicoleBus *app, int argc, const char **argv);
                void handleQuitMessage( MicoleBus *app, int argc, const char **argv);
                /*      Suspends the MicoleAgent. Suspending means that its methods are unbound from
                        the Micole bus. Sending Suspend message using sendMessage
                */
                void handleSuspendMessage( MicoleBus *app, int argc, const char **argv);
                void handleResumeMessage( MicoleBus *app, int argc, const char **argv);

                void handleRegisterReply( MicoleBus *app, int argc, const char **argv);
                void handleStartMessage( MicoleBus *app, int argc, const char **argv);
                void handlePrintIDMessage( MicoleBus *app, int argc, const char **argv);
                //virtual void onDirectMessage( MicoleBus *app, int id, const char *arg );

                int sendMessage( const char *message);

                int sendMessage( const string message);

                void sendMessage(const char *to, const char *message);

        protected:
                MicoleAgent(const string &name, const string &type, const char *domain = "127.255.255.255:2010");

                int bindMessage(const char *regexp, MicoleCallback * cb);
                void unBindMessage(int messageId);
                void unBindMessage(MicoleBinding &binding);

                virtual void suspendAgent();

                virtual void resumeAgent();

                virtual void stopAgent();

                void obtainIdentifier();

                static MicoleBus* bus;
                //Ivy* bus;
                vector<MicoleBinding> bindings;
                AgentState state;
                int resumeId;

        private:
                string agentName;
                string agentType;
                //int identifier;//the agent identifier, received on start-up from agent network...(not used yet)
                string identifier;      
};
 //end core

#endif

---