csLibFbg.cs

Go to the documentation of this file.

/*
 *  csharpFreiburg - src/CSharpFreiburg/src/CsLibFbg/csLibFbg.cs
 *  
 *  (C) 2004 - Freiburg - Project - Group
 *  ------------------------------------------------------
 *  EMail: freiburg AT compiler-factory DOT de
 *  ------------------------------------------------------
 *  all rights reserved
 */

using System;
using System.Text;
using System.Collections;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;

[assembly:AssemblyVersionAttribute("2.0.0.0")]

namespace Freiburg {

public unsafe class Timer
{
    private const string MSGQUE_DLL = "libFreiburg20";

    private IntPtr timer;

    public IntPtr value 
    {
        get { return timer; }
    }

    [DllImport(MSGQUE_DLL)]
    private static extern IntPtr MqStatCreate (IntPtr msgque);

    public Timer (IntPtr msgque)
    {
        timer = MqStatCreate (msgque);
    }

    [DllImport(MSGQUE_DLL)]
    private static extern void MqStatDelete (IntPtr *timerP);

    ~Timer () 
    {
        fixed (IntPtr *timerP = &timer) {
            MqStatDelete (timerP);
        }
    }

    [DllImport(MSGQUE_DLL)]
    private static extern void MqStatInit (IntPtr timer);

    public void Init ()
    {
        MqStatInit (timer);
    }
}

public unsafe class Stat
{
    private const string MSGQUE_DLL = "libFreiburg20";

    [StructLayout(LayoutKind.Sequential)]
    private struct StatCtxS {
        public IntPtr   msgque; 
        public IntPtr   name;   
        public short    level;  
        public int      count;  
        public double   val;    
    };

    private StatCtxS *stat;

    [DllImport(MSGQUE_DLL)]
    private static extern StatCtxS* MqStatCtxCreate(IntPtr msgque, string name, int count, short level);

    public Stat (IntPtr msgque, string name, int count, short level)
    {
        stat = MqStatCtxCreate (msgque, name, count, level);
    }

    [DllImport(MSGQUE_DLL)]
    private static extern void MqStatCtxDelete (StatCtxS **stat);

    ~Stat() {
        fixed (StatCtxS **statP = &stat) {
            MqStatCtxDelete (statP);
        }
    }

    public double value 
    {
        get { return stat->val; }
        set { stat->val = value; }
    }

    [DllImport(MSGQUE_DLL, CharSet=CharSet.Ansi)]
    private static extern IntPtr MqBufferGetC (IntPtr buf);

    public string name 
    {
        get { return Marshal.PtrToStringAnsi (MqBufferGetC(stat->name)); }
    }

    [DllImport(MSGQUE_DLL)]
    private static extern void MqStatCtxCalc (StatCtxS *stat, IntPtr timer);

    public void Calc (Timer timer)
    {
        MqStatCtxCalc (stat, timer.value);
    }

    [DllImport(MSGQUE_DLL)]
    private static extern void MqStatCtxPrint (StatCtxS *stat);

    public void Print ()
    {
        MqStatCtxPrint (stat);
    }
}

public unsafe abstract class Msgque
{
    private const string MSGQUE_DLL = "libFreiburg20";

    private static Mutex createMutex = new Mutex();
    private static Mutex deleteMutex = new Mutex();
    
    // this is the delegate declaration
    protected delegate int HdlF(CsS *msgque, IntPtr data);

    public enum ErrorE { OK, ERROR, WARNING, CONTINUE };    

    private enum CsE { CLIENT, SERVER };

    [StructLayout(LayoutKind.Sequential)]
    protected struct CsS {
        public    IntPtr    myCtx;      
        public    IntPtr    temp;       
        public    BufferS*  name;       

        public    short     debug;      
        public    short     stat;       
        public    short     silent;     
        public    short     binary;     

        public    IntPtr    send;       
        public    IntPtr    read;       
        public    IntPtr    io;         
        public    IntPtr    error;      
        public    IntPtr    statistic;  
    }
    protected CsS *msgque;              

/*****************************************************************************/
/*                                                                           */
/*                            context management                             */
/*                                                                           */
/*****************************************************************************/

    [DllImport(MSGQUE_DLL)]
    private static extern IntPtr MqBufferLCreate(IntPtr error, int num);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqBufferLAppendHC(IntPtr lbuf, string option, string value);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqBufferLAppendH2(IntPtr lbuf, string option, short value);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqBufferLAppendHP(IntPtr lbuf, string option, IntPtr value);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqBufferLAppend(IntPtr lbuf, IntPtr value);
    [DllImport(MSGQUE_DLL)]
    private static extern IntPtr MqBufferCreateC(IntPtr error, string value);
    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqCreate(IntPtr context, IntPtr argv, CsS **msgqueP);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqDelete(CsS **msgqueP);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqBufferLLog(IntPtr lbuf, string name);

  // create a context
    public Msgque(Msgque parent, string name, string server, string[] argv) {
        ErrorE ret;
        IntPtr largv = MqBufferLCreate (IntPtr.Zero, 10);

      // 1. system data
        if (parent != null)
            MqBufferLAppendHP (largv, "-parent", (IntPtr) parent.msgque);
        MqBufferLAppendHC (largv, "-name", name);
        MqBufferLAppendHC (largv, "-server", server);
        MqBufferLAppendH2 (largv, "-type", (short) CsE.CLIENT);

      // 2. all other arguments
        foreach (string item in argv ) {
          MqBufferLAppend (largv, MqBufferCreateC (IntPtr.Zero, item));
        }

        //MqBufferLLog (largv, "largv");

      // 3. create msgque
        createMutex.WaitOne();
        fixed (CsS **msgqueP = &msgque) {
            ret = (MqCreate(IntPtr.Zero, largv, msgqueP));
        }
        createMutex.ReleaseMutex();
        ErrorCheck(ret);
    }

  // delete a context
    ~Msgque() {
        deleteMutex.WaitOne();
        fixed (CsS **msgqueP = &msgque) {
            MqDelete (msgqueP);
        }
        deleteMutex.ReleaseMutex();
    }

/*****************************************************************************/
/*                                                                           */
/*                            ErrorS related                                 */
/*                                                                           */
/*****************************************************************************/

    [DllImport(MSGQUE_DLL, CharSet=CharSet.Ansi)]
    public static extern string MqErrorGetString(IntPtr error);
    [DllImport(MSGQUE_DLL)]
    protected static extern void MqErrorReset (IntPtr error);
    [DllImport(MSGQUE_DLL)]
    protected static extern ErrorE MqErrorGetStatus (IntPtr error);

    protected void ErrorCheck( ErrorE err ) {
        if (err == ErrorE.ERROR)
            throw new ApplicationException(MqErrorGetString(msgque->error));
    }

/*****************************************************************************/
/*                                                                           */
/*                            service handle                                 */
/*                                                                           */
/*****************************************************************************/

    [DllImport(MSGQUE_DLL)]
    protected static extern ErrorE MqServiceCreate(IntPtr msgque, string token, HdlF handle, IntPtr data);

    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqServiceDelete(IntPtr msgque, string token);

/*****************************************************************************/
/*                                                                           */
/*                                   read                                    */
/*                                                                           */
/*****************************************************************************/

    public enum AllocE {
        DYNAMIC,    
        STATIC      
    }

    public enum TypeE{   
      BIN = 'B',    
      STR = 'C',    
      INT2 = '2',   
      INT4 = '4',   
      INT8 = '8',   
      FLT4 = 'F',   
      FLT8 = 'D',   
      PTR = 'P',    
      LST = 'L',    
      RET = 'R',    
      STA = 'S' 
    };

    [StructLayout(LayoutKind.Explicit, CharSet=CharSet.Ansi)]
    public struct BufferU {
      [ FieldOffset( 0 )]
      public IntPtr         B;      
      [ FieldOffset( 0 )]
      public IntPtr         C;      
      [ FieldOffset( 0 )]
      public short          *I2;    
      [ FieldOffset( 0 )]
      public int            *I4;    
      [ FieldOffset( 0 )]
      public long           *I8;    
      [ FieldOffset( 0 )]
      public float          *F;     
      [ FieldOffset( 0 )]
      public double    *D;          
      [ FieldOffset( 0 )]
      public IntPtr         *P;     
      [ FieldOffset( 0 )]
      public IntPtr         L;      
      [ FieldOffset( 0 )]
      public IntPtr         R;      
     };
    
    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
    public struct BufferS {
        public IntPtr   error;      
        public IntPtr   data;       
        public int      size;       
        public int      cursize;    
        public int      numItems;   
        public BufferU  cur;        
        public AllocE   alloc;      
        public TypeE    type;       
    };

/*****************************************************************************/
/*                                                                           */
/*                                   send                                    */
/*                                                                           */
/*****************************************************************************/

    [DllImport(MSGQUE_DLL)]
    private static extern void MqSendSTART(IntPtr send);

    [DllImport(MSGQUE_DLL)]
    private static extern void MqSendC(IntPtr send, string val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend2(IntPtr send, short val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend4(IntPtr send, int val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend8(IntPtr send, long val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSendF(IntPtr send, float val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSendD(IntPtr send, double val);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSendB(IntPtr send, byte[] val, int size);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend_LST_START(IntPtr send);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend_LST_END(IntPtr send);

    private void sendO (Object oObj)
    {
      Type type = oObj.GetType();

      // error test only in STRING mode
        if (msgque->binary == 0)
            MqErrorReset (msgque->error);
        
        if (type == typeof(string)) {
            MqSendC(msgque->send, (string) oObj);
        } else if (type == typeof(short)) {
            MqSend2(msgque->send, (short) oObj);
        } else if (type == typeof(int)) {
            MqSend4(msgque->send, (int) oObj);
        } else if (type == typeof(long)) {
            MqSend8(msgque->send, (long) oObj);
        } else if (type == typeof(float)) {
            MqSendF(msgque->send, (float) oObj);
        } else if (type == typeof(double)) {
            MqSendD(msgque->send, (double) oObj);
        } else if (type.IsArray) {
            if (type == typeof(byte[])) {
                MqSendB(msgque->send, (byte[]) oObj, ((byte[]) oObj).Length);
            } else {
                MqSend_LST_START (msgque->send);
                sendL((Object[])oObj);
                MqSend_LST_END (msgque->send);
            }
        } else {
            MqSendC(msgque->send, oObj.ToString());
        }

      // error test only in STRING mode
        if (msgque->binary == 0)
            ErrorCheck (MqErrorGetStatus(msgque->error));
    }

    private void sendL (Object[] oList)
    {
        foreach (Object oEle in oList) {
            sendO (oEle);
        }
    }

    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqReadU(IntPtr read, BufferS **buf);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqReadCreate_LST_Ref(IntPtr read, BufferS *buf, IntPtr *readRef);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqReadDelete_LST_Ref(IntPtr *read);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqReadRET(IntPtr read, BufferS *buf);

    protected Object readO ( IntPtr read ) {
        BufferS *buf;
        ErrorCheck(MqReadU (read, &buf));
        
        switch (buf->type) {
            case TypeE.STR: 
                return Marshal.PtrToStringAnsi(buf->cur.C);
            case TypeE.BIN:
                byte[] ret = new byte[buf->cursize];
                Marshal.Copy(buf->cur.B, ret, 0, buf->cursize);
                return ret;
            case TypeE.INT2:
                return (*buf->cur.I2);
            case TypeE.INT4:
                return (*buf->cur.I4);
            case TypeE.INT8:
                return (*buf->cur.I8);
            case TypeE.FLT4:
                return (*buf->cur.F);
            case TypeE.FLT8:
                return (*buf->cur.D);
            case TypeE.PTR:
                return (*buf->cur.P);
            case TypeE.LST:
                IntPtr readRef;
                MqReadCreate_LST_Ref (read, buf, &readRef);
                Object[] oRet = ReadL (readRef);
                MqReadDelete_LST_Ref (&readRef);
                return oRet;
            case TypeE.RET:
                MqReadRET (read, buf);
                return null;
            case TypeE.STA:
                throw new ApplicationException("unable to read a STA object");
        }
        throw new ApplicationException("unknown buffer->type");
    }

    [DllImport(MSGQUE_DLL)]
    private static extern int MqReadGetNumItems(IntPtr read);

    protected Object[] ReadLR( IntPtr read ) {
      int num = MqReadGetNumItems (read)-1;
      Object[] oList = new Object[num];
      for (int i=0; i<num; i++) {
        oList[i] = readO (read);
      }
      readO (read);     // read return-item
      return oList;
    }

    protected Object[] ReadL( IntPtr read ) {
      int num = MqReadGetNumItems (read);
      Object[] oList = new Object[num];
      for (int i=0; i<num; i++) {
        oList[i] = readO (read);
      }
      return oList;
    }

    /*****************************************************************************/
    /*                    call service and wait for answer                       */
    /*****************************************************************************/

    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqSendEND_AND_WAIT(IntPtr send, string token, int timeout);
    [DllImport(MSGQUE_DLL)]
    private static extern char MqReadGetReturnCode(IntPtr read);
    [DllImport(MSGQUE_DLL)]
    private static extern short MqReadGetReturnNum(IntPtr read);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqReadCreate_RET_Ref(IntPtr read, IntPtr *readRef);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqReadDelete_RET_Ref(IntPtr *readRef);

    protected Object[] CallService (string token, int timeout, params Object[] argv) 
    {
        MqSendSTART (msgque->send);
        if (argv != null) sendL (argv);
        ErrorCheck(MqSendEND_AND_WAIT(msgque->send, token, timeout));
        Object [] oList = ReadLR (msgque->read);
        if (MqReadGetReturnCode(msgque->read) != 'O') {
            IntPtr read = msgque->read;
            IntPtr readRef;
            char retCode = MqReadGetReturnCode (read);
            int  retNum  = MqReadGetReturnNum (read);
            MqReadCreate_RET_Ref (read, &readRef);
            Object[] retL = ReadL (readRef);
            MqReadDelete_RET_Ref (&readRef);
            StringBuilder msg = new StringBuilder(Marshal.PtrToStringAnsi(msgque->name->data));
            msg.AppendFormat (" <Tok|{0}> <Nr|{1}>", token, retNum);
            char[] delimiter = new char[1] {'\n'};
            foreach (Object oElm in retL) {
                foreach (string strE in oElm.ToString().Split(delimiter)) {
                    msg.Append ("\n -> ");
                    msg.Append (strE);
                }
            }
            if (retCode == 'W') {
                Console.WriteLine ("WARNING: {0}", msg);
            }
            throw new ApplicationException(msg.ToString());
        }

        return oList;
    }

    /*****************************************************************************/
    /*                 call service and don't wait for answer                    */
    /*****************************************************************************/

    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqSendEND(IntPtr send, string token, IntPtr trans);

    protected void CallService (string token, params Object[] argv) 
    {
        MqSendSTART (msgque->send);
        sendL (argv);
        ErrorCheck(MqSendEND(msgque->send, token, IntPtr.Zero));
    }

    /*****************************************************************************/
    /*                      answer for a service call                            */
    /*****************************************************************************/

    protected enum RetCodeE { OK = 'O', WARNING = 'W', ERROR = 'E' };

    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend_RET_OK(IntPtr send);
    [DllImport(MSGQUE_DLL)]
    private static extern void MqSend_RET_START(IntPtr send, RetCodeE retcode, int retnum);
    [DllImport(MSGQUE_DLL)]
    private static extern ErrorE MqSendEND_RETR(IntPtr send, IntPtr trans);

    protected void SendReturnAndWait (RetCodeE retcode, int retnum, string rettext, params Object[] argv)
    {
        MqSendSTART (msgque->send);
        sendL (argv);
        if (retcode == RetCodeE.OK) {
            MqSend_RET_OK (msgque->send);
        } else {
            MqSend_RET_START (msgque->send, retcode, retnum);
            MqSendC (msgque->send, rettext);
        }
        ErrorCheck (MqSendEND_RETR (msgque->send, IntPtr.Zero));
    }

    /*****************************************************************************/
    /*                              statistics                                   */
    /*****************************************************************************/

    public Stat StatCreate (string name, int count, short level)
    {
        return new Stat((IntPtr) msgque, name, count, level);
    }

    public Timer TimerCreate ()
    {
        return new Timer((IntPtr) msgque);
    }

}

// END - NameSpace Freiburg
}

---