LcConfigC.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
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 cslcconfig {
 
#if META_IS_OBJECT
  public partial class LcConfigC
#else
  public partial class LcConfigC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(LcConfigC));
    private readonly static ThreadLocal<LcConfigC> MK_NULL = new ThreadLocal<LcConfigC>(() => {
      return (LcConfigC) atomSelfNull(ctor);
    });
 
    public static LcConfigC LcConfigC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (LcConfigC) atomObjNew(typeof(LcConfigC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static LcConfigC LcConfigC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (LcConfigC) atomObjCreate(typeof(LcConfigC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr LcConfigC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void LcConfigC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadCFG (IntPtr mkrt) {
      Lc.LcCsTypeUpdate(mkrt, LcCsTypeLookupE.CFG, LcConfigC_SelfCreate, LcConfigC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static LcConfigC() {
      // M0("LcConfigC");
      LcConfig.Setup();
      SetupThreadCFG(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
    internal LcConfigC (IntPtr cfgP) : base(cfgP) {
    }
 
  } // END - class "LcConfigC"
 
  // BEGIN-LcConfigC - created by 'cs_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Class-Export,sc_
 
    new public static LcConfigC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Lc.LcConfigHandleResolve(IntPtr.Zero, netHdl);
      return LcConfigC.LcConfigC_ObjNew(__retVal__L);
    }
 
    // doc-key: LcConfigC,LcConfigC-Class-Export,om_
 
    // skip class-overload: HandleGet = LcConfigHandleGet → MkObjectHandleGet
 
    // LcConfigC_Class_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Class-Introspection,oc_
 
    new public LcConfigC Next ()  {
      IntPtr __retVal__L = Lc.LcConfigNext(hdl);
      return LcConfigC.LcConfigC_ObjNew(__retVal__L);
    }
 
    new public LcConfigC Prev ()  {
      IntPtr __retVal__L = Lc.LcConfigPrev(hdl);
      return LcConfigC.LcConfigC_ObjNew(__retVal__L);
    }
 
    // doc-key: LcConfigC,LcConfigC-Class-Introspection,sc_
 
    new public static LcConfigC Instances ()  {
      IntPtr __retVal__L = Lc.LcConfigInstances(IntPtr.Zero);
      return LcConfigC.LcConfigC_ObjNew(__retVal__L);
    }
 
    // LcConfigC_Class_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Class-Misc,sc_
 
    new public static LcConfigC GetNull ()  {
      IntPtr __retVal__L = Lc.LcConfigGetNull();
      return LcConfigC.LcConfigC_ObjNew(__retVal__L);
    }
 
    // LcConfigC_Class_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Error,om_
 
    public LcErrorTypeE ErrorType ()  {
      LcErrorTypeE __retVal__L = Lc.LcConfigErrorType(hdl);
      return __retVal__L;
    }
 
    // LcConfigC_Error_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Get,om_
 
    public LcConfigFormatE GetDefaultFormat ()  {
      LcConfigFormatE __retVal__L = Lc.LcConfigGetDefaultFormat(hdl);
      return __retVal__L;
    }
 
    public short GetFloatPrecision ()  {
      Int16 __retVal__L = Lc.LcConfigGetFloatPrecision(hdl);
      return __retVal__L;
    }
 
    public string GetIncludeDir ()  {
      IntPtr __retVal__L = Lc.LcConfigGetIncludeDir(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public bool GetOption (LcConfigOptionsEF option)  {
      bool __retVal__L = Lc.LcConfigGetOption(hdl, option);
      return __retVal__L;
    }
 
    public LcConfigOptionsEF GetOptions ()  {
      LcConfigOptionsEF __retVal__L = Lc.LcConfigGetOptions(hdl);
      return __retVal__L;
    }
 
    public short GetTabWidth ()  {
      Int16 __retVal__L = Lc.LcConfigGetTabWidth(hdl);
      return __retVal__L;
    }
 
    // LcConfigC_Get_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Lookup,oc_
 
    public LcSettingC Lookup (string path)  {
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      IntPtr __retVal__L = Lc.LcConfigLookup(hdl, path_cstr);
      Marshal.FreeHGlobal(path_cstr);
      return LcSettingC.LcSettingC_ObjNew(__retVal__L);
    }
 
    // doc-key: LcConfigC,LcConfigC-Lookup,omo
 
    public bool LookupBool (string path)  {
      bool value_out;
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      MkErrorE errVal = Lc.LcConfigLookupBool(hdl, path_cstr, out value_out);
      Marshal.FreeHGlobal(path_cstr);
      MkErrorC.Check(hdl, errVal);
      return value_out;
    }
 
    public double LookupFloat (string path)  {
      Double value_out;
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      MkErrorE errVal = Lc.LcConfigLookupFloat(hdl, path_cstr, out value_out);
      Marshal.FreeHGlobal(path_cstr);
      MkErrorC.Check(hdl, errVal);
      return value_out;
    }
 
    public int LookupInt (string path)  {
      Int32 value_out;
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      MkErrorE errVal = Lc.LcConfigLookupInt(hdl, path_cstr, out value_out);
      Marshal.FreeHGlobal(path_cstr);
      MkErrorC.Check(hdl, errVal);
      return value_out;
    }
 
    public long LookupInt64 (string path)  {
      Int64 value_out;
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      MkErrorE errVal = Lc.LcConfigLookupInt64(hdl, path_cstr, out value_out);
      Marshal.FreeHGlobal(path_cstr);
      MkErrorC.Check(hdl, errVal);
      return value_out;
    }
 
    public string LookupString (string path)  {
      IntPtr value_out;
      IntPtr path_cstr = Marshal.StringToHGlobalAnsi(path);
      MkErrorE errVal = Lc.LcConfigLookupString(hdl, path_cstr, out value_out);
      Marshal.FreeHGlobal(path_cstr);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(value_out);
    }
 
    // LcConfigC_Lookup_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Misc,oc_
 
    public LcSettingC RootSetting ()  {
      IntPtr __retVal__L = Lc.LcConfigRootSetting(hdl);
      return LcSettingC.LcSettingC_ObjNew(__retVal__L);
    }
 
    // doc-key: LcConfigC,LcConfigC-Misc,om_
 
    public void Clear ()  {
      Lc.LcConfigClear(hdl);
    }
 
    new public void Log (MkObjectC fmtobj = null, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Lc.LcConfigLog(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void ReadFile (string filename)  {
      IntPtr filename_cstr = Marshal.StringToHGlobalAnsi(filename);
      MkErrorE errVal = Lc.LcConfigReadFile(hdl, filename_cstr);
      Marshal.FreeHGlobal(filename_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ReadString (string str)  {
      IntPtr str_cstr = Marshal.StringToHGlobalAnsi(str);
      MkErrorE errVal = Lc.LcConfigReadString(hdl, str_cstr);
      Marshal.FreeHGlobal(str_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void WriteFile (string filename)  {
      IntPtr filename_cstr = Marshal.StringToHGlobalAnsi(filename);
      MkErrorE errVal = Lc.LcConfigWriteFile(hdl, filename_cstr);
      Marshal.FreeHGlobal(filename_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: LcConfigC,LcConfigC-Misc,omo
 
    public string WriteString ()  {
      IntPtr val_out;
      MkErrorE errVal = Lc.LcConfigWriteString(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out);
    }
 
    // LcConfigC_Misc_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-Set,om_
 
    public void SetDefaultFormat (LcConfigFormatE format)  {
      Lc.LcConfigSetDefaultFormat(hdl, format);
    }
 
    public void SetFloatPrecision (short digits)  {
      Lc.LcConfigSetFloatPrecision(hdl, digits);
    }
 
    public void SetIncludeDir (string include_dir)  {
      IntPtr include_dir_cstr = Marshal.StringToHGlobalAnsi(include_dir);
      Lc.LcConfigSetIncludeDir(hdl, include_dir_cstr);
      Marshal.FreeHGlobal(include_dir_cstr);
    }
 
    public void SetIncludeFunc (LcConfigIncludeCCB fConfigIncludeData = null)  {
      LcConfigIncludeCallF fConfigIncludeCall = LcConfigIncludeCall;
      IntPtr fConfigIncludeData_ptr = fConfigIncludeData == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new LcCall(mkrt,fConfigIncludeData));
      if (fConfigIncludeData_ptr == IntPtr.Zero) fConfigIncludeCall = null;
      MkErrorE errVal = Lc.LcConfigSetIncludeFunc(mkrt, hdl, fConfigIncludeCall, fConfigIncludeData_ptr, LcConfigIncludeFree);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SetOption (LcConfigOptionsEF option, bool flag)  {
      Lc.LcConfigSetOption(hdl, option, flag);
    }
 
    public void SetOptions (LcConfigOptionsEF options)  {
      Lc.LcConfigSetOptions(hdl, options);
    }
 
    public void SetSettingDeleteFunc (LcSettingDeleteCCB fSettingDeleteData = null)  {
      LcSettingDeleteCallF fSettingDeleteCall = LcSettingDeleteCall;
      IntPtr fSettingDeleteData_ptr = fSettingDeleteData == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new LcCall(mkrt,fSettingDeleteData));
      if (fSettingDeleteData_ptr == IntPtr.Zero) fSettingDeleteCall = null;
      MkErrorE errVal = Lc.LcConfigSetSettingDeleteFunc(mkrt, hdl, fSettingDeleteCall, fSettingDeleteData_ptr, LcSettingDeleteFree);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SetTabWidth (short width)  {
      Lc.LcConfigSetTabWidth(hdl, width);
    }
 
    // LcConfigC_Set_CS_API
  }
 
  public partial class LcConfigC {
 
 
    // doc-key: LcConfigC,LcConfigC-TOR,sCc
 
    protected static IntPtr CTOR ()  {
      IntPtr __retVal__L = Lc.LcConfigCreate();
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("LcConfigC.CTOR");
      }
      return (IntPtr)__retVal__L;
    }
 
    public LcConfigC() : this(CTOR()) {}
 
    public static LcConfigC Create ()  {
      IntPtr __retVal__L = Lc.LcConfigCreate();
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("LcConfigC.Create");
      }
      return LcConfigC.LcConfigC_ObjCreate(__retVal__L);
    }
 
    // LcConfigC_TOR_CS_API
  }
 
  // END-LcConfigC - created by 'cs_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
} // END - namespace "cslcconfig"