[System] UriKind.RelativeOrAbsolute workaround.
[mono.git] / mcs / class / Mono.Posix / Mono.Unix.Native / NativeConvert.generated.cs
index b22ee2bbed8205a21483f1a51194e1fac6ea2284..d9097f8d7a3394610167957639000144950b97e6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * This file was automatically generated by create-native-map from ../../class/lib/default/Mono.Posix.dll.
+ * This file was automatically generated by create-native-map from ../../class/lib/net_2_0/Mono.Posix.dll.
  *
  * DO NOT MODIFY.
  */
@@ -54,6 +54,38 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromAtFlags")]
+               private static extern int FromAtFlags (AtFlags value, out Int32 rval);
+
+               public static bool TryFromAtFlags (AtFlags value, out Int32 rval)
+               {
+                       return FromAtFlags (value, out rval) == 0;
+               }
+
+               public static Int32 FromAtFlags (AtFlags value)
+               {
+                       Int32 rval;
+                       if (FromAtFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToAtFlags")]
+               private static extern int ToAtFlags (Int32 value, out AtFlags rval);
+
+               public static bool TryToAtFlags (Int32 value, out AtFlags rval)
+               {
+                       return ToAtFlags (value, out rval) == 0;
+               }
+
+               public static AtFlags ToAtFlags (Int32 value)
+               {
+                       AtFlags rval;
+                       if (ToAtFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromConfstrName")]
                private static extern int FromConfstrName (ConfstrName value, out Int32 rval);
 
@@ -118,6 +150,70 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollEvents")]
+               private static extern int FromEpollEvents (EpollEvents value, out UInt32 rval);
+
+               public static bool TryFromEpollEvents (EpollEvents value, out UInt32 rval)
+               {
+                       return FromEpollEvents (value, out rval) == 0;
+               }
+
+               public static UInt32 FromEpollEvents (EpollEvents value)
+               {
+                       UInt32 rval;
+                       if (FromEpollEvents (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollEvents")]
+               private static extern int ToEpollEvents (UInt32 value, out EpollEvents rval);
+
+               public static bool TryToEpollEvents (UInt32 value, out EpollEvents rval)
+               {
+                       return ToEpollEvents (value, out rval) == 0;
+               }
+
+               public static EpollEvents ToEpollEvents (UInt32 value)
+               {
+                       EpollEvents rval;
+                       if (ToEpollEvents (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollFlags")]
+               private static extern int FromEpollFlags (EpollFlags value, out Int32 rval);
+
+               public static bool TryFromEpollFlags (EpollFlags value, out Int32 rval)
+               {
+                       return FromEpollFlags (value, out rval) == 0;
+               }
+
+               public static Int32 FromEpollFlags (EpollFlags value)
+               {
+                       Int32 rval;
+                       if (FromEpollFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollFlags")]
+               private static extern int ToEpollFlags (Int32 value, out EpollFlags rval);
+
+               public static bool TryToEpollFlags (Int32 value, out EpollFlags rval)
+               {
+                       return ToEpollFlags (value, out rval) == 0;
+               }
+
+               public static EpollFlags ToEpollFlags (Int32 value)
+               {
+                       EpollFlags rval;
+                       if (ToEpollFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromErrno")]
                private static extern int FromErrno (Errno value, out Int32 rval);
 
@@ -214,6 +310,38 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromFlock")]
+               private static extern int FromFlock (ref Flock source, IntPtr destination);
+
+               public static bool TryCopy (ref Flock source, IntPtr destination)
+               {
+                       return FromFlock (ref source, destination) == 0;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToFlock")]
+               private static extern int ToFlock (IntPtr source, out Flock destination);
+
+               public static bool TryCopy (IntPtr source, out Flock destination)
+               {
+                       return ToFlock (source, out destination) == 0;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromIovec")]
+               private static extern int FromIovec (ref Iovec source, IntPtr destination);
+
+               public static bool TryCopy (ref Iovec source, IntPtr destination)
+               {
+                       return FromIovec (ref source, destination) == 0;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToIovec")]
+               private static extern int ToIovec (IntPtr source, out Iovec destination);
+
+               public static bool TryCopy (IntPtr source, out Iovec destination)
+               {
+                       return ToIovec (source, out destination) == 0;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
                private static extern int FromLockType (LockType value, out Int16 rval);
 
@@ -710,22 +838,6 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
-               [DllImport (LIB, EntryPoint="Mono_Posix_FromStat")]
-               private static extern int FromStat (ref Stat source, IntPtr destination);
-
-               public static bool TryCopy (ref Stat source, IntPtr destination)
-               {
-                       return FromStat (ref source, destination) == 0;
-               }
-
-               [DllImport (LIB, EntryPoint="Mono_Posix_ToStat")]
-               private static extern int ToStat (IntPtr source, out Stat destination);
-
-               public static bool TryCopy (IntPtr source, out Stat destination)
-               {
-                       return ToStat (source, out destination) == 0;
-               }
-
                [DllImport (LIB, EntryPoint="Mono_Posix_FromSysconfName")]
                private static extern int FromSysconfName (SysconfName value, out Int32 rval);
 
@@ -854,6 +966,22 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromTimespec")]
+               private static extern int FromTimespec (ref Timespec source, IntPtr destination);
+
+               public static bool TryCopy (ref Timespec source, IntPtr destination)
+               {
+                       return FromTimespec (ref source, destination) == 0;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToTimespec")]
+               private static extern int ToTimespec (IntPtr source, out Timespec destination);
+
+               public static bool TryCopy (IntPtr source, out Timespec destination)
+               {
+                       return ToTimespec (source, out destination) == 0;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromTimeval")]
                private static extern int FromTimeval (ref Timeval source, IntPtr destination);
 
@@ -886,6 +1014,22 @@ namespace Mono.Unix.Native {
                        return ToTimezone (source, out destination) == 0;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromUtimbuf")]
+               private static extern int FromUtimbuf (ref Utimbuf source, IntPtr destination);
+
+               public static bool TryCopy (ref Utimbuf source, IntPtr destination)
+               {
+                       return FromUtimbuf (ref source, destination) == 0;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToUtimbuf")]
+               private static extern int ToUtimbuf (IntPtr source, out Utimbuf destination);
+
+               public static bool TryCopy (IntPtr source, out Utimbuf destination)
+               {
+                       return ToUtimbuf (source, out destination) == 0;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
                private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);