/home/dko/projects/mobilec/tags/MobileC-v1.10.2/MobileC-v1.10.2/src/win32/LibMC.net/LibMC/MCAgent.cs

Go to the documentation of this file.

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

namespace LibMC
{
    public class MCAgent
    {
        private IntPtr agent_p;
        private String name = "";
        private int id = -1;
        private int numTasks = -1;
        private MC_AgentStatus_e status = MC_AgentStatus_e.MC_NO_STATUS;
        private MC_AgentType_e type = MC_AgentType_e.MC_NONE;

        public enum MC_AgentType_e
        {
            MC_NONE = -1,           
            MC_REMOTE_AGENT = 0,    
            MC_LOCAL_AGENT,         
            MC_RETURN_AGENT         
        };

        public enum MC_AgentStatus_e
        {
            MC_NO_STATUS = -1, 
            MC_WAIT_CH = 0,    
            MC_WAIT_MESSGSEND, 
            MC_AGENT_ACTIVE,   
            MC_AGENT_NEUTRAL,  
            MC_AGENT_SUSPENDED,
            MC_WAIT_FINISHED   
        };

        public MCAgent()
        {
            // Not using wrapper - default value
            agent_p = IntPtr.Zero;
        }

        internal MCAgent(IntPtr ip)
        {
            Agent = ip;
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("MCAgent:\n\tName: {0}\n\tID: {1}\n\tNumTasks: {2}\n\tStatus: {3}\n\tType: {4}", 
                AgentName.ToString(), 
                AgentID.ToString(),
                AgentNumTasks.ToString(),
                Enum.GetName(typeof(MC_AgentStatus_e), AgentStatus),
                Enum.GetName(typeof(MC_AgentType_e), AgentType));

            return sb.ToString();
        }

        /*
         * Accessors
         */
        internal IntPtr Agent
        {
            get
            {
                if (agent_p == IntPtr.Zero)
                    throw new InvalidAgentException();
                else
                    return agent_p;
            }
            set
            {
                if (agent_p == IntPtr.Zero)
                {
                    agent_p = value;
                    GetAgentFields();
                }
                else
                    throw new InvalidAgentException("Attempting to assign new agent to non-zero agent pointer!");
            }
        }

        private void GetAgentFields()
        {
            id = MCAgency._MC_GetAgentID(Agent);
            name = MCAgency._MC_GetAgentName(Agent);
            numTasks = MCAgency._MC_GetAgentNumTasks(Agent);
            status = MCAgency._MC_GetAgentStatus(Agent);
            type = MCAgency._MC_GetAgentType(Agent);
        }

        public int AgentID
        {
            get
            {
                return id;
            }
            /*set
            {
                id = value;
            }*/
        }

        public String AgentName
        {
            get
            {
                return name;
            }
            /*set
            {
                name = value;
            }*/
        }

        public int AgentNumTasks
        {
            get
            {
                return numTasks;
            }
            /*set
            {
                numTasks = value;
            }*/
        }

        public MC_AgentStatus_e AgentStatus
        {
            get
            {
                status = MCAgency._MC_GetAgentStatus(Agent);
                return status;
            }
            set
            {
                MCAgency._MC_SetAgentStatus(Agent, value);
                status = MCAgency._MC_GetAgentStatus(Agent);
            }
        }

        public MC_AgentType_e AgentType
        {
            get
            {
                return type;
            }
            /*set
            {
                type = value;
            }*/
        }

        public bool Valid
        {
            get
            {
                return (agent_p != IntPtr.Zero);
            }
            /*set
            {
                type = value;
            }*/
        }

        /*
         * Static casting operators
         */
        static public implicit operator IntPtr(MCAgent agent)
        {
            return agent.Agent;
        }

        static public implicit operator MCAgent(IntPtr ip)
        {
            return new MCAgent(ip);
        }

        /*
         * Agent functions
         */

        public int DeleteAgent()
        {
            return MCAgency._MC_DeleteAgent(Agent);
        }

        public String GetAgentXMLString()
        {
            return MCAgency._MC_GetAgentXMLString(Agent);
        }

        public int PrintAgentCode()
        {
            return MCAgency._MC_PrintAgentCode(Agent);
        }

        public String RetrieveAgentCode()
        {
            return MCAgency._MC_RetrieveAgentCode(Agent);
        }

        public int TerminateAgent()
        {
            return MCAgency._MC_TerminateAgent(Agent);
        }

        /*public int _MC_CallAgentFunc(IntPtr agent, String funcName, void* returnVal, void* varg);*/
        /*public void* _MC_GetAgentExecEngine(IntPtr agent);*/
        /*public int _MC_GetAgentReturnData(IntPtr agent, int task_num, void **data, int *dim, int **extent);*/

        /*
         * ACL Functions
         */

        public int AclPost(MCAclMessage message)
        {
            return MCAgency._MC_AclPost(Agent, message.AclMsg);
        }

        public MCAclMessage AclRetrieve()
        {
            IntPtr temp = MCAgency._MC_AclRetrieve(Agent);
            if (temp == IntPtr.Zero)
                return new MCAclMessage();
            else
                return new MCAclMessage(temp);
        }

        public MCAclMessage AclWaitRetrieve()
        {
            IntPtr temp = MCAgency._MC_AclWaitRetrieve(Agent);
            if (temp == IntPtr.Zero)
                return new MCAclMessage();
            else
                return new MCAclMessage(temp);
        }

        public int CallAgentFunc(String funcName, IntPtr retval, IntPtr varg)
        {
            return MCAgency._MC_CallAgentFunc(Agent, funcName, retval, varg);
        }

        public int CallAgentFunc(String funcName, ref object retval, ref object varg)
        {
            int temp = -1;
            IntPtr vargp = IntPtr.Zero, retvalp = IntPtr.Zero;
            try
            {
                vargp = Marshal.AllocHGlobal(Marshal.SizeOf(varg));
                Marshal.StructureToPtr(varg, vargp, false);
                retvalp = Marshal.AllocHGlobal(Marshal.SizeOf(retval));

                temp = CallAgentFunc(funcName, // The function to call
                    retvalp, // A place for the return value (void*)
                    vargp);  // The marshaled pointer to the argument (a structure)
                retval = Marshal.PtrToStructure(retvalp, retval.GetType());
                varg = Marshal.PtrToStructure(vargp, varg.GetType());
            }
            catch (OutOfMemoryException ex)
            {
                Console.WriteLine("Error allocating memory for calling agent functions: " + ex.Message);
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine("Error marshaling arguments for calling agent functions: " + ex.Message);
            }
            finally
            {
                Marshal.FreeHGlobal(vargp);
                Marshal.FreeHGlobal(retvalp);
            }

            return temp;
        }

        public IntPtr GetAgentExecEngine()
        {
            return MCAgency._MC_GetAgentExecEngine(Agent);
        }

        public int GetAgentReturnData(int task_num, IntPtr data, IntPtr dim, IntPtr extent)
        {
            //return _MC_GetAgentReturnData(IntPtr agent, int task_num, IntPtr data, IntPtr dim, IntPtr extent);
            throw new Exception("GetAgentReturnData is not yet implemented!");
        }
    }

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

        public InvalidAgentException()
            : base(msg)
        {
        }

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

---