MqFactoryC.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define META_STATIC_OVERWRITE
 
using csmkkernel;
 
/* LABEL-START */
 
using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Collections.Generic;
using System.Threading;
 
namespace csmqmsgque {
 
#if META_IS_OBJECT
  public partial class MqFactoryC
#else
  public partial class MqFactoryC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MqFactoryC));
    private readonly static ThreadLocal<MqFactoryC> MK_NULL = new ThreadLocal<MqFactoryC>(() => {
      return (MqFactoryC) atomSelfNull(ctor);
    });
 
    public static MqFactoryC MqFactoryC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MqFactoryC) atomObjNew(typeof(MqFactoryC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static MqFactoryC MqFactoryC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MqFactoryC) atomObjCreate(typeof(MqFactoryC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr MqFactoryC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void MqFactoryC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadFCT (IntPtr mkrt) {
      Mq.MqCsTypeUpdate(mkrt, MqCsTypeLookupE.FCT, MqFactoryC_SelfCreate, MqFactoryC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static MqFactoryC() {
      // M0("MqFactoryC");
      MqMsgque.Setup();
      SetupThreadFCT(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
     static MqFactoryC() {
      // init libmqmsgque
      MqMsgque.Setup();
      Mq.MqCsTypeUpdate(IntPtr.Zero, MqCsTypeLookupE.FCT, MqFactoryC_SelfCreate, MqFactoryC_SelfUnlink);
      // init factory
      if (MqFactoryC.DefaultIdent() == "libmqmsgque") {
       MqFactoryCT<MqContextC>.Add("csmqmsgque").Default().Initial();
      }
    }
 
    internal MqFactoryC (IntPtr ptr) : base(ptr) {
    }
 
    ~MqFactoryC() {
      Mq.MqFactoryFree(mkrt,hdl);
    }
 
    private static MqFactoryCTorF     fFactoryCreate    = FactoryCreate;
    private static MqFactoryDTorF     fFactoryDelete    = FactoryDelete;
    private static MqFactoryDataFreeF fFactoryDataFree  = FactoryDataFree;
    private static MqFactoryDataCopyF fFactoryDataCopy  = FactoryDataCopy;
 
  // private
 
    private static MkErrorE FactoryCreate (
      IntPtr mkrt, IntPtr mqrt, IntPtr tmpl, MqFactoryE create, IntPtr fct, out IntPtr contextP
    ) {
      contextP = IntPtr.Zero;
      try {
        Object tmplO = MqContextC.MqContextC_ObjNewOrNull(tmpl);
        ConstructorInfo constr = null;
 
        if (tmplO != null && (create & (MqFactoryE.CHILD|MqFactoryE.SLAVE|MqFactoryE.FILTER)) > 0) {
          constr = tmplO.GetType().GetConstructor(new Type[] {typeof(MqContextC)});
        } else {
          IntPtr data = Mq.MqFactoryItemGetCreateData(fct);
          constr = (ConstructorInfo)GCHandle.FromIntPtr(data).Target;
        }
        Object[] args = new Object[] {tmplO};
        contextP = ((MqContextC)(constr).Invoke(args)).hdl;
 
      } catch (Exception ex) {
        MkRuntimeC.Reset();
        return MkErrorC.DEFAULT().Catch(ex).Stack();
      }
      if ((create & (MqFactoryE.CHILD)) > 0) {
        Mq.MqSetupDup (mkrt, contextP, tmpl);
      }
      return MkErrorE.OK;
    }
 
    private static void FactoryDelete (IntPtr mkrt, IntPtr ctx, bool doFactoryCleanup, IntPtr fct) {
      IntPtr self = Mk.CsGetSelfPtr(ctx);
      // C# has no "selfDelete" function
      if (self != IntPtr.Zero) {
        var selfO = GCHandle.FromIntPtr(self).Target;
        if (selfO != null) {
          ((MkObjectC)selfO).Dispose();
          return;
        }
      }
      // last resort
      Mq.MqContextDelete(mkrt, ctx);
    }
 
    private static void FactoryDataFree (IntPtr mkrt, ref IntPtr data) {
      GCHandle.FromIntPtr(data).Free();
      data = IntPtr.Zero;
    }
 
    private static void FactoryDataCopy (IntPtr mkrt, ref IntPtr data) {
      data = (IntPtr)GCHandle.Alloc((ConstructorInfo)GCHandle.FromIntPtr(data).Target);
    }
 
  } // END - class "MqFactoryC"
 
 
  // BEGIN-MqFactoryC - created by 'cs_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-Class-Export,sc_
 
    new public static MqFactoryC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Mq.MqFactoryHandleResolve(IntPtr.Zero, netHdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-Class-Export,om_
 
    // skip class-overload: HandleGet = MqFactoryHandleGet → MkObjectHandleGet
 
    // MqFactoryC_Class_CS_API
  }
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-Class-Introspection,oc_
 
    new public MqFactoryC Next ()  {
      IntPtr __retVal__L = Mq.MqFactoryNext(hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    new public MqFactoryC Prev ()  {
      IntPtr __retVal__L = Mq.MqFactoryPrev(hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-Class-Introspection,sc_
 
    new public static MqFactoryC Instances ()  {
      IntPtr __retVal__L = Mq.MqFactoryInstances(IntPtr.Zero);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // MqFactoryC_Class_CS_API
  }
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-Class-Misc,sc_
 
    new public static MqFactoryC GetNull ()  {
      IntPtr __retVal__L = Mq.MqFactoryGetNull();
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // MqFactoryC_Class_CS_API
  }
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-Get,sc_
 
    public static MqFactoryC Get (string ident = "")  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr __retVal__L = Mq.MqFactoryGet(IntPtr.Zero, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    public static MqFactoryC GetCalled (string ident = "")  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr __retVal__L = Mq.MqFactoryGetCalled(IntPtr.Zero, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    public static MqFactoryC GetCalled (MkBufferListC largs)  {
      IntPtr largs_hdl = MkBufferListC.getOBJ("MkBufferListC",largs);
      IntPtr __retVal__L = Mq.MqFactoryGetCalledL(IntPtr.Zero, largs_hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-Get,om_
 
    public string GetOriginalIdent ()  {
      IntPtr __retVal__L = Mq.MqFactoryGetOriginalIdent(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MqFactoryC_Get_CS_API
  }
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-Misc,oc_
 
    public MqFactoryC Default ()  {
      IntPtr __retVal__L = Mq.MqFactoryDefault(mkrt, hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    public MqFactoryC Initial ()  {
      IntPtr __retVal__L = Mq.MqFactoryInitial(mkrt, hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-Misc,oco
 
    public MqContextC New ()  {
      IntPtr val_out;
      MkErrorE errVal = Mq.MqFactoryNew(mkrt, hdl, IntPtr.Zero, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MqContextC.MqContextC_ObjNew(val_out);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-Misc,om_
 
    // skip class-overload: Log = MqFactoryLog → MkObjectLog
 
    // doc-key: MqFactoryC,MqFactoryC-Misc,sm_
 
    public static string DefaultIdent ()  {
      IntPtr __retVal__L = Mq.MqFactoryDefaultIdent(IntPtr.Zero);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static string InitialIdent ()  {
      IntPtr __retVal__L = Mq.MqFactoryInitialIdent(IntPtr.Zero);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static void LogAll ([CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mq.MqFactoryLogAll(IntPtr.Zero, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // MqFactoryC_Misc_CS_API
  }
 
  public partial class MqFactoryC {
 
 
    // doc-key: MqFactoryC,MqFactoryC-TOR,oCx
 
    public MqFactoryC Dup2 (string ident)  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr __retVal__L = Mq.MqFactoryDup2(mkrt, hdl, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MqFactoryC.Dup2");
      }
      return MqFactoryC.MqFactoryC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MqFactoryC,MqFactoryC-TOR,sCc
 
    public MqFactoryC(Type constructor, string ident = null) : this(CTOR(constructor, ident)) {}
 
    public static MqFactoryC Add (Type constructor, string ident = null)  {
      if (ident == null) {ident = constructor.Name;}
      if (ident == null) {ident = constructor.Name;}
      IntPtr constructor_c;
      // this require an Class-Constructor with Signature 'CLASS(MqContextC)' and will be implemented as
      // 'CLASS(MqContextC tmpl=null) : base(tmpl) {...}' to support the Default-Constructor as well.
      ConstructorInfo constr = constructor.GetConstructor(new Type[] {typeof(MqContextC)});
      if (constr == null) {
        throw new System.Exception("unable to get Factory constructor");
      } else {
        constructor_c = (IntPtr) GCHandle.Alloc(constr);
      }
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr __retVal__L = Mq.MqFactoryAdd(IntPtr.Zero, IntPtr.Zero, fFactoryCreate, constructor_c, fFactoryDataFree, fFactoryDataCopy, fFactoryDelete, IntPtr.Zero, null, null, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MqFactoryC.Add");
      }
      return MqFactoryC.MqFactoryC_ObjCreate(__retVal__L);
    }
 
    protected static IntPtr CTOR (Type constructor, string ident = null)  {
      if (ident == null) {ident = constructor.Name;}
      IntPtr constructor_c;
      // this require an Class-Constructor with Signature 'CLASS(MqContextC)' and will be implemented as
      // 'CLASS(MqContextC tmpl=null) : base(tmpl) {...}' to support the Default-Constructor as well.
      ConstructorInfo constr = constructor.GetConstructor(new Type[] {typeof(MqContextC)});
      if (constr == null) {
        throw new System.Exception("unable to get Factory constructor");
      } else {
        constructor_c = (IntPtr) GCHandle.Alloc(constr);
      }
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr __retVal__L = Mq.MqFactoryAdd(IntPtr.Zero, IntPtr.Zero, fFactoryCreate, constructor_c, fFactoryDataFree, fFactoryDataCopy, fFactoryDelete, IntPtr.Zero, null, null, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MqFactoryC.CTOR");
      }
      return (IntPtr)__retVal__L;
    }
 
    // MqFactoryC_TOR_CS_API
  }
 
  // END-MqFactoryC - created by 'cs_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  //
  // ##############################################################################################
  //
 
  public class MqFactoryCT<T> : MqFactoryC
      where T : MqContextC
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MqFactoryCT<T>));
 
    internal MqFactoryCT(IntPtr ptr) : base(ptr) {
//printTyp(ptr,"MqFactoryT");
    }
 
    private static MqFactoryCT<T> MqFactoryCT_ObjNew (IntPtr hdl) {
      return (MqFactoryCT<T>) atomObjNew(typeof(MqFactoryCT<T>), ctor, hdl);
    }
 
    public static MqFactoryCT<T> Add(string ident = null) {
#if META_STRONG_REF
      return MqFactoryCT<T>.MqFactoryCT_ObjNew(CTOR(typeof(T),ident));
#else
      var fct = CTOR(typeof(T),ident);
      var ret = MqFactoryCT<T>.MqFactoryCT_ObjNew(fct);
      Mk.CsMakePersistent(fct);
      return ret;
#endif
    }
 
    public new T New() {
      return (T) base.New();
    }
 
    public new MqFactoryCT<T> Initial() {
      return (MqFactoryCT<T>) base.Initial();
    }
 
  }
 
  //
  // ##############################################################################################
  //
 
  internal class MqFactoryCException : Exception
  {
    internal MqFactoryCException(string message = "") : base("MqFactoryC exception: " + message) {}
  }
 
} // END - namespace "csmqmsgque"