Wes xx mediapipe integration

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Framework/Port/Status.cs

@@ -0,0 +1,273 @@
+// Copyright (c) 2021 homuler
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Mediapipe
+{
+  public class Status : MpResourceHandle
+  {
+    public enum StatusCode : int
+    {
+      Ok = 0,
+      Cancelled = 1,
+      Unknown = 2,
+      InvalidArgument = 3,
+      DeadlineExceeded = 4,
+      NotFound = 5,
+      AlreadyExists = 6,
+      PermissionDenied = 7,
+      ResourceExhausted = 8,
+      FailedPrecondition = 9,
+      Aborted = 10,
+      OutOfRange = 11,
+      Unimplemented = 12,
+      Internal = 13,
+      Unavailable = 14,
+      DataLoss = 15,
+      Unauthenticated = 16,
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public readonly struct StatusArgs
+    {
+      private readonly StatusCode _code;
+      private readonly IntPtr _message;
+
+      private StatusArgs(StatusCode code, string message = null)
+      {
+        _code = code;
+        _message = Marshal.StringToHGlobalAnsi(message);
+      }
+
+      public static StatusArgs Ok()
+      {
+        return new StatusArgs(StatusCode.Ok);
+      }
+
+      public static StatusArgs Cancelled(string message = null)
+      {
+        return new StatusArgs(StatusCode.Cancelled, message);
+      }
+
+      public static StatusArgs Unknown(string message = null)
+      {
+        return new StatusArgs(StatusCode.Unknown, message);
+      }
+
+      public static StatusArgs InvalidArgument(string message = null)
+      {
+        return new StatusArgs(StatusCode.InvalidArgument, message);
+      }
+
+      public static StatusArgs DeadlineExceeded(string message = null)
+      {
+        return new StatusArgs(StatusCode.DeadlineExceeded, message);
+      }
+
+      public static StatusArgs NotFound(string message = null)
+      {
+        return new StatusArgs(StatusCode.NotFound, message);
+      }
+
+      public static StatusArgs AlreadyExists(string message = null)
+      {
+        return new StatusArgs(StatusCode.AlreadyExists, message);
+      }
+
+      public static StatusArgs PermissionDenied(string message = null)
+      {
+        return new StatusArgs(StatusCode.PermissionDenied, message);
+      }
+
+      public static StatusArgs ResourceExhausted(string message = null)
+      {
+        return new StatusArgs(StatusCode.ResourceExhausted, message);
+      }
+
+      public static StatusArgs FailedPrecondition(string message = null)
+      {
+        return new StatusArgs(StatusCode.FailedPrecondition, message);
+      }
+
+      public static StatusArgs Aborted(string message = null)
+      {
+        return new StatusArgs(StatusCode.Aborted, message);
+      }
+
+      public static StatusArgs OutOfRange(string message = null)
+      {
+        return new StatusArgs(StatusCode.OutOfRange, message);
+      }
+
+      public static StatusArgs Unimplemented(string message = null)
+      {
+        return new StatusArgs(StatusCode.Unimplemented, message);
+      }
+
+      public static StatusArgs Internal(string message = null)
+      {
+        return new StatusArgs(StatusCode.Internal, message);
+      }
+
+      public static StatusArgs Unavailable(string message = null)
+      {
+        return new StatusArgs(StatusCode.Unavailable, message);
+      }
+
+      public static StatusArgs DataLoss(string message = null)
+      {
+        return new StatusArgs(StatusCode.DataLoss, message);
+      }
+
+      public static StatusArgs Unauthenticated(string message = null)
+      {
+        return new StatusArgs(StatusCode.Unauthenticated, message);
+      }
+    }
+
+    public Status(IntPtr ptr, bool isOwner = true) : base(ptr, isOwner) { }
+
+    protected override void DeleteMpPtr()
+    {
+      UnsafeNativeMethods.absl_Status__delete(ptr);
+    }
+
+    private bool? _ok;
+    private int? _rawCode;
+
+    public void AssertOk()
+    {
+      if (!Ok())
+      {
+        throw new MediaPipeException(ToString());
+      }
+    }
+
+    public bool Ok()
+    {
+      if (_ok is bool valueOfOk)
+      {
+        return valueOfOk;
+      }
+      _ok = SafeNativeMethods.absl_Status__ok(mpPtr);
+      return (bool)_ok;
+    }
+
+    public StatusCode Code()
+    {
+      return (StatusCode)RawCode();
+    }
+
+    public int RawCode()
+    {
+      if (_rawCode is int valueOfRawCode)
+      {
+        return valueOfRawCode;
+      }
+      _rawCode = SafeNativeMethods.absl_Status__raw_code(mpPtr);
+      return (int)_rawCode;
+    }
+
+    public override string ToString()
+    {
+      return MarshalStringFromNative(UnsafeNativeMethods.absl_Status__ToString);
+    }
+
+    public static Status Build(StatusCode code, string message, bool isOwner = true)
+    {
+      UnsafeNativeMethods.absl_Status__i_PKc((int)code, message, out var ptr).Assert();
+
+      return new Status(ptr, isOwner);
+    }
+
+    public static Status Ok(bool isOwner = true)
+    {
+      return Build(StatusCode.Ok, "", isOwner);
+    }
+
+    public static Status Cancelled(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Cancelled, message, isOwner);
+    }
+
+    public static Status Unknown(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Unknown, message, isOwner);
+    }
+
+    public static Status InvalidArgument(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.InvalidArgument, message, isOwner);
+    }
+
+    public static Status DeadlineExceeded(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.DeadlineExceeded, message, isOwner);
+    }
+
+    public static Status NotFound(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.NotFound, message, isOwner);
+    }
+
+    public static Status AlreadyExists(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.AlreadyExists, message, isOwner);
+    }
+
+    public static Status PermissionDenied(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.PermissionDenied, message, isOwner);
+    }
+
+    public static Status ResourceExhausted(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.ResourceExhausted, message, isOwner);
+    }
+
+    public static Status FailedPrecondition(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.FailedPrecondition, message, isOwner);
+    }
+
+    public static Status Aborted(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Aborted, message, isOwner);
+    }
+
+    public static Status OutOfRange(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.OutOfRange, message, isOwner);
+    }
+
+    public static Status Unimplemented(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Unimplemented, message, isOwner);
+    }
+
+    public static Status Internal(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Internal, message, isOwner);
+    }
+
+    public static Status Unavailable(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Unavailable, message, isOwner);
+    }
+
+    public static Status DataLoss(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.DataLoss, message, isOwner);
+    }
+
+    public static Status Unauthenticated(string message = "", bool isOwner = true)
+    {
+      return Build(StatusCode.Unauthenticated, message, isOwner);
+    }
+  }
+}