/home/dko/projects/mobilec/trunk/src/win32/LibMC.net/LibMC/MCAgency.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace LibMC
{
    public partial class MCAgency
    {
        public enum MCAgencyState
        {
            NoState = -1,       
            Initialized = 0,    
            Running,            
            Halted,             
            Ended,              
        }

        public enum ChShellType
        {
            CH_REGULARCH = 0,   
            CH_SAFECH = 1,      
        }

        private IntPtr agency_p = IntPtr.Zero;
        private MCAgencyOptions_t options;
        private int port = -1;
        private MCAgencyState state = MCAgencyState.NoState;

        public MCAgency()
        {
            options = new MCAgencyOptions_t();
            _MC_InitializeAgencyOptions(ref options);
            state = MCAgencyState.Initialized;
        }

        private IntPtr Agency
        {
            get
            {
                if (agency_p == IntPtr.Zero)
                    throw new InvalidAgentException();
                else
                    return agency_p;
            }
            set
            {
                if (value == IntPtr.Zero)
                    throw new InvalidAgentException("Attempting to assign null pointer to agency internal pointer!");
                else if (agency_p == IntPtr.Zero)
                    agency_p = value;
                else
                    throw new InvalidAgentException("Attempting to assign new agency to non-zero agency pointer!");
            }
        }

        public int Port
        {
            get
            {
                return port;
            }
            set
            {
                port = value;
            }
        }

        public MCAgencyState State
        {
            get
            {
                return state;
            }
        }

        /*
         * Agency functions
         */

        public int Initialize()
        {
            if (port == -1)
                return -1;
            else
            {
                Agency = MCAgency._MC_Initialize(port, ref options);
                state = MCAgencyState.Running;
                return 0;
            }
        }

        public int End()
        {
            int temp = MCAgency._MC_End(Agency);
            state = MCAgencyState.Ended;
            return temp;
        }

        public int ChInitializeOptions(ChShellType shellType, String home)
        {
            ChOptions_t options = new ChOptions_t();
            options.chhome = home;
            options.shelltype = (int)shellType;
            return _MC_ChInitializeOptions(Agency, options);
        }

        /* \brief       Sets all threads for the agency to "on."
         * 
         * Sets all threads for the agency to "on." This is also the default state
         * for the agency.
         * 
         * \returns     The return value of the underlying MC_SetThreadsAllOn function.
         * 
         * \note        This function must be called before the agency is started.
         */
        public int SetThreadsAllOn()
        {
            return _MC_SetThreadsAllOn(ref options);
        }

        public int SetThreadsAllOff()
        {
            return _MC_SetThreadsAllOff(ref options);
        }

        public int SetThreadOn(MC_ThreadIndex_e index)
        {
            return _MC_SetThreadOn(ref options, index);
        }

        public int SetThreadOff(MC_ThreadIndex_e index)
        {
            return _MC_SetThreadOff(ref options, index);
        }

        public int HaltAgency()
        {
            int temp = _MC_HaltAgency(Agency);
            state = MCAgencyState.Halted;
            return temp;
        }

        public int ResumeAgency()
        {
            int temp = _MC_ResumeAgency(Agency);
            state = MCAgencyState.Running;
            return temp;
        }

        public int SetDefaultAgentStatus(MCAgent.MC_AgentStatus_e status)
        {
            return _MC_SetDefaultAgentStatus(Agency, status);
        }

        public MCAgent WaitRetrieveAgent()
        {
            IntPtr temp = _MC_WaitRetrieveAgent(Agency);
            if (temp != IntPtr.Zero)
                return new MCAgent(temp);
            else
                return new MCAgent();
        }

        public int WaitAgent()
        {
            return _MC_WaitAgent(Agency);
        }

        /*
         * Migration functions
         */

        public int SendAgentMigrationMessageFile(String filename, String hostname, int port)
        {
            return MCAgency._MC_SendAgentMigrationMessageFile(Agency, filename, hostname, port);
        }

        public int LoadAgentMigrationMessageFile(String filename)
        {
            return MCAgency._MC_SendAgentMigrationMessageFile(Agency, filename, "localhost", this.Port);
        }

        public int SendAgentMigrationMessage(String message, String hostname, int port)
        {
            return _MC_SendAgentMigrationMessage(Agency, message, hostname, port);
        }

        /*
         * Signals and threading functions
         */

        public int CondBroadcast(int id)
        {
            return _MC_CondBroadcast(Agency, id);
        }

        public int CondSignal(int id)
        {
            return _MC_CondSignal(Agency, id);
        }

        public int CondReset(int id)
        {
            return _MC_CondReset(Agency, id);
        }

        public int CondWait(int id)
        {
            return _MC_CondWait(Agency, id);
        }

        public int MutexLock(int id)
        {
            return _MC_MutexLock(Agency, id);
        }

        public int MutexUnlock(int id)
        {
            return _MC_MutexUnlock(Agency, id);
        }

        public int SemaphorePost(int id)
        {
            return _MC_SemaphorePost(Agency, id);
        }

        public int SemaphoreWait(int id)
        {
            return _MC_SemaphoreWait(Agency, id);
        }

        public int ResetSignal()
        {
            return _MC_ResetSignal(Agency);
        }

        public int SyncDelete(int id)
        {
            return _MC_SyncDelete(Agency, id);
        }

        public int SyncInit(int id)
        {
            return _MC_SyncInit(Agency, id);
        }

        public int WaitSignal(MC_Signal_e /*int*/ signals)
        {
            return _MC_WaitSignal(Agency, (int)signals);
        }

        public int BarrierDelete(int id)
        {
            return _MC_BarrierDelete(Agency, id);
        }

        public int BarrierInit(int id, int num_procs)
        {
            return _MC_BarrierInit(Agency, id, num_procs);
        }

        /*
         * Steering functions
         */

        public MC_SteerCommand_e SteerControl()
        {
            return _MC_SteerControl();
        }

        /*public int _MC_Steer(IntPtr agency, int (*funcptr)(void* data), void *arg);*/
        public int Steer(IntPtr funcptr, IntPtr arg)
        {
            //return _MC_Steer(Agency, IntPtr funcptr, IntPtr arg);
            throw new Exception("Steer() is not yet implemented!");
        }

        /*
         * Services
         */

        public int RegisterService(MCAgent agent, int agentID, String agentName, String[] serviceNames, int numServices)
        {
            return _MC_RegisterService(Agency, agent.Agent, agentID, agentName, serviceNames, numServices);
        }

        /*private static extern int _MC_SearchForService(IntPtr agency, String searchString, char*** agentNames, char*** serviceNames, int** agentIDs, int* numResults);*/
        public int SearchForService(String searchString, IntPtr agentNames, IntPtr serviceNames, IntPtr agentIDs, IntPtr numResults)
        {
            //return _MC_SearchForService(IntPtr agency, String searchString, IntPtr agentNames, IntPtr serviceNames, IntPtr agentIDs, IntPtr numResults);
            throw new Exception("SearchForService() is not yet implemented!");
        }

        /*
         * Agent functions
        */

        public int AddAgent(MCAgent agent)
        {
            return _MC_AddAgent(Agency, agent.Agent);
        }

        public MCAgent FindAgentByName(String name)
        {
            return new MCAgent(_MC_FindAgentByName(Agency, name));
        }

        public MCAgent FindAgentByID(int id)
        {
            return new MCAgent(_MC_FindAgentByID(Agency, id));
        }

        public MCAgent RetrieveAgent()
        {
            return new MCAgent(_MC_RetrieveAgent(Agency));
        }

        /*
         * ACL Functions
         */

        public int AclSend(MCAclMessage acl_message)
        {
            return MCAgency._MC_AclSend(Agency, acl_message.AclMsg);
        }

        public int MainLoop()
        {
            return _MC_MainLoop(Agency);
        }
    }

    public class InvalidAgencyException : SystemException
    {
        private const String msg = "Private agency pointer not valid.";

        public InvalidAgencyException()
            : base(msg)
        {
        }

        public InvalidAgencyException(String exc)
            : base(exc)
        {
        }
    }
}

---