<Type Name="NativeConvert" FullName="Mono.Unix.Native.NativeConvert">
  <TypeSignature Language="C#" Value="public sealed class NativeConvert" />
  <AssemblyInfo>
    <AssemblyName>Mono.Posix</AssemblyName>
    <AssemblyVersion>2.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <ThreadingSafetyStatement>
  All public static members of this type are safe for multithreaded operations. 
  No instance members are guaranteed to be thread safe.
  </ThreadingSafetyStatement>
  <Base>
    <BaseTypeName>System.Object</BaseTypeName>
  </Base>
  <Interfaces />
  <Members>
    <!-- BEGIN GENERATED CONTENT
/*
 * This file was automatically generated by make-map from Mono.Posix.dll.
 *
 * DO NOT MODIFY.
 */

      -->
    <Member MemberName="TryFromAccessModes">
      <MemberSignature Language="C#" Value="public static bool TryFromAccessModes (Mono.Unix.Native.AccessModes value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.AccessModes" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.AccessModes" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToAccessModes" />
      </Docs>
    </Member>
    <Member MemberName="FromAccessModes">
      <MemberSignature Language="C#" Value="public static int FromAccessModes (Mono.Unix.Native.AccessModes value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.AccessModes" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.AccessModes" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToAccessModes" />
      </Docs>
    </Member>
    <Member MemberName="TryToAccessModes">
      <MemberSignature Language="C#" Value="public static bool TryToAccessModes (int value, out Mono.Unix.Native.AccessModes rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.AccessModes&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.AccessModes" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToAccessModes" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.AccessModes" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromAccessModes" />
      </Docs>
    </Member>
    <Member MemberName="ToAccessModes">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.AccessModes ToAccessModes (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.AccessModes</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.AccessModes" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromAccessModes" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToAccessModes" />
      </Docs>
    </Member>
    <Member MemberName="TryFromConfstrName">
      <MemberSignature Language="C#" Value="public static bool TryFromConfstrName (Mono.Unix.Native.ConfstrName value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.ConfstrName" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.ConfstrName" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromConfstrName" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToConfstrName" />
      </Docs>
    </Member>
    <Member MemberName="FromConfstrName">
      <MemberSignature Language="C#" Value="public static int FromConfstrName (Mono.Unix.Native.ConfstrName value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.ConfstrName" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.ConfstrName" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToConfstrName" />
      </Docs>
    </Member>
    <Member MemberName="TryToConfstrName">
      <MemberSignature Language="C#" Value="public static bool TryToConfstrName (int value, out Mono.Unix.Native.ConfstrName rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.ConfstrName&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.ConfstrName" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToConfstrName" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.ConfstrName" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromConfstrName" />
      </Docs>
    </Member>
    <Member MemberName="ToConfstrName">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.ConfstrName ToConfstrName (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.ConfstrName</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.ConfstrName" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromConfstrName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToConfstrName" />
      </Docs>
    </Member>
    <Member MemberName="TryFromDirectoryNotifyFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromDirectoryNotifyFlags (Mono.Unix.Native.DirectoryNotifyFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.DirectoryNotifyFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.DirectoryNotifyFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToDirectoryNotifyFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromDirectoryNotifyFlags">
      <MemberSignature Language="C#" Value="public static int FromDirectoryNotifyFlags (Mono.Unix.Native.DirectoryNotifyFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.DirectoryNotifyFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.DirectoryNotifyFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToDirectoryNotifyFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToDirectoryNotifyFlags">
      <MemberSignature Language="C#" Value="public static bool TryToDirectoryNotifyFlags (int value, out Mono.Unix.Native.DirectoryNotifyFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.DirectoryNotifyFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.DirectoryNotifyFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToDirectoryNotifyFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.DirectoryNotifyFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromDirectoryNotifyFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToDirectoryNotifyFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.DirectoryNotifyFlags ToDirectoryNotifyFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.DirectoryNotifyFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.DirectoryNotifyFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromDirectoryNotifyFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToDirectoryNotifyFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromErrno">
      <MemberSignature Language="C#" Value="public static bool TryFromErrno (Mono.Unix.Native.Errno value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.Errno" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.Errno" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromErrno" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToErrno" />
      </Docs>
    </Member>
    <Member MemberName="FromErrno">
      <MemberSignature Language="C#" Value="public static int FromErrno (Mono.Unix.Native.Errno value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.Errno" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.Errno" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToErrno" />
      </Docs>
    </Member>
    <Member MemberName="TryToErrno">
      <MemberSignature Language="C#" Value="public static bool TryToErrno (int value, out Mono.Unix.Native.Errno rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.Errno&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.Errno" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToErrno" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.Errno" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromErrno" />
      </Docs>
    </Member>
    <Member MemberName="ToErrno">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.Errno ToErrno (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.Errno</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.Errno" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromErrno" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToErrno" />
      </Docs>
    </Member>
    <Member MemberName="TryFromFcntlCommand">
      <MemberSignature Language="C#" Value="public static bool TryFromFcntlCommand (Mono.Unix.Native.FcntlCommand value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FcntlCommand" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.FcntlCommand" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromFcntlCommand" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFcntlCommand" />
      </Docs>
    </Member>
    <Member MemberName="FromFcntlCommand">
      <MemberSignature Language="C#" Value="public static int FromFcntlCommand (Mono.Unix.Native.FcntlCommand value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FcntlCommand" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.FcntlCommand" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFcntlCommand" />
      </Docs>
    </Member>
    <Member MemberName="TryToFcntlCommand">
      <MemberSignature Language="C#" Value="public static bool TryToFcntlCommand (int value, out Mono.Unix.Native.FcntlCommand rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.FcntlCommand&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.FcntlCommand" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToFcntlCommand" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.FcntlCommand" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFcntlCommand" />
      </Docs>
    </Member>
    <Member MemberName="ToFcntlCommand">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.FcntlCommand ToFcntlCommand (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.FcntlCommand</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.FcntlCommand" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFcntlCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFcntlCommand" />
      </Docs>
    </Member>
    <Member MemberName="TryFromFilePermissions">
      <MemberSignature Language="C#" Value="public static bool TryFromFilePermissions (Mono.Unix.Native.FilePermissions value, out uint rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FilePermissions" />
        <Parameter Name="rval" Type="System.UInt32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.FilePermissions" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFilePermissions" />
      </Docs>
    </Member>
    <Member MemberName="FromFilePermissions">
      <MemberSignature Language="C#" Value="public static uint FromFilePermissions (Mono.Unix.Native.FilePermissions value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.UInt32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FilePermissions" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.FilePermissions" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFilePermissions" />
      </Docs>
    </Member>
    <Member MemberName="TryToFilePermissions">
      <MemberSignature Language="C#" Value="public static bool TryToFilePermissions (uint value, out Mono.Unix.Native.FilePermissions rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.FilePermissions&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.FilePermissions" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToFilePermissions" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.FilePermissions" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFilePermissions" />
      </Docs>
    </Member>
    <Member MemberName="ToFilePermissions">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.FilePermissions ToFilePermissions (uint value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.FilePermissions</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.FilePermissions" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromFilePermissions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToFilePermissions" />
      </Docs>
    </Member>
    <Member MemberName="TryFromLockType">
      <MemberSignature Language="C#" Value="public static bool TryFromLockType (Mono.Unix.Native.LockType value, out short rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.LockType" />
        <Parameter Name="rval" Type="System.Int16&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.LockType" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromLockType" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockType" />
      </Docs>
    </Member>
    <Member MemberName="FromLockType">
      <MemberSignature Language="C#" Value="public static short FromLockType (Mono.Unix.Native.LockType value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int16</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.LockType" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.LockType" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockType" />
      </Docs>
    </Member>
    <Member MemberName="TryToLockType">
      <MemberSignature Language="C#" Value="public static bool TryToLockType (short value, out Mono.Unix.Native.LockType rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
        <Parameter Name="rval" Type="Mono.Unix.Native.LockType&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.LockType" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToLockType" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.LockType" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockType" />
      </Docs>
    </Member>
    <Member MemberName="ToLockType">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.LockType ToLockType (short value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.LockType</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.LockType" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockType" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockType" />
      </Docs>
    </Member>
    <Member MemberName="TryFromLockfCommand">
      <MemberSignature Language="C#" Value="public static bool TryFromLockfCommand (Mono.Unix.Native.LockfCommand value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.LockfCommand" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.LockfCommand" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromLockfCommand" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockfCommand" />
      </Docs>
    </Member>
    <Member MemberName="FromLockfCommand">
      <MemberSignature Language="C#" Value="public static int FromLockfCommand (Mono.Unix.Native.LockfCommand value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.LockfCommand" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.LockfCommand" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockfCommand" />
      </Docs>
    </Member>
    <Member MemberName="TryToLockfCommand">
      <MemberSignature Language="C#" Value="public static bool TryToLockfCommand (int value, out Mono.Unix.Native.LockfCommand rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.LockfCommand&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.LockfCommand" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToLockfCommand" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.LockfCommand" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockfCommand" />
      </Docs>
    </Member>
    <Member MemberName="ToLockfCommand">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.LockfCommand ToLockfCommand (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.LockfCommand</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.LockfCommand" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromLockfCommand" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToLockfCommand" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMlockallFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromMlockallFlags (Mono.Unix.Native.MlockallFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MlockallFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MlockallFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMlockallFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromMlockallFlags">
      <MemberSignature Language="C#" Value="public static int FromMlockallFlags (Mono.Unix.Native.MlockallFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MlockallFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MlockallFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMlockallFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToMlockallFlags">
      <MemberSignature Language="C#" Value="public static bool TryToMlockallFlags (int value, out Mono.Unix.Native.MlockallFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MlockallFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MlockallFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMlockallFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MlockallFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMlockallFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToMlockallFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MlockallFlags ToMlockallFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MlockallFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MlockallFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMlockallFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMlockallFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMmapFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromMmapFlags (Mono.Unix.Native.MmapFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MmapFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MmapFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromMmapFlags">
      <MemberSignature Language="C#" Value="public static int FromMmapFlags (Mono.Unix.Native.MmapFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MmapFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MmapFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToMmapFlags">
      <MemberSignature Language="C#" Value="public static bool TryToMmapFlags (int value, out Mono.Unix.Native.MmapFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MmapFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MmapFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMmapFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MmapFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToMmapFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MmapFlags ToMmapFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MmapFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MmapFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMmapProts">
      <MemberSignature Language="C#" Value="public static bool TryFromMmapProts (Mono.Unix.Native.MmapProts value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MmapProts" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MmapProts" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapProts" />
      </Docs>
    </Member>
    <Member MemberName="FromMmapProts">
      <MemberSignature Language="C#" Value="public static int FromMmapProts (Mono.Unix.Native.MmapProts value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MmapProts" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MmapProts" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapProts" />
      </Docs>
    </Member>
    <Member MemberName="TryToMmapProts">
      <MemberSignature Language="C#" Value="public static bool TryToMmapProts (int value, out Mono.Unix.Native.MmapProts rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MmapProts&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MmapProts" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMmapProts" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MmapProts" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapProts" />
      </Docs>
    </Member>
    <Member MemberName="ToMmapProts">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MmapProts ToMmapProts (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MmapProts</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MmapProts" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMmapProts" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMmapProts" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMountFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromMountFlags (Mono.Unix.Native.MountFlags value, out ulong rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MountFlags" />
        <Parameter Name="rval" Type="System.UInt64&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MountFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMountFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromMountFlags">
      <MemberSignature Language="C#" Value="public static ulong FromMountFlags (Mono.Unix.Native.MountFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.UInt64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MountFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MountFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMountFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToMountFlags">
      <MemberSignature Language="C#" Value="public static bool TryToMountFlags (ulong value, out Mono.Unix.Native.MountFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MountFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MountFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMountFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MountFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMountFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToMountFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MountFlags ToMountFlags (ulong value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MountFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MountFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMountFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMountFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMremapFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromMremapFlags (Mono.Unix.Native.MremapFlags value, out ulong rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MremapFlags" />
        <Parameter Name="rval" Type="System.UInt64&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MremapFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMremapFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromMremapFlags">
      <MemberSignature Language="C#" Value="public static ulong FromMremapFlags (Mono.Unix.Native.MremapFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.UInt64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MremapFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MremapFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMremapFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToMremapFlags">
      <MemberSignature Language="C#" Value="public static bool TryToMremapFlags (ulong value, out Mono.Unix.Native.MremapFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MremapFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MremapFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMremapFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MremapFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMremapFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToMremapFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MremapFlags ToMremapFlags (ulong value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MremapFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MremapFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMremapFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMremapFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromMsyncFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromMsyncFlags (Mono.Unix.Native.MsyncFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MsyncFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MsyncFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMsyncFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromMsyncFlags">
      <MemberSignature Language="C#" Value="public static int FromMsyncFlags (Mono.Unix.Native.MsyncFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.MsyncFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.MsyncFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMsyncFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToMsyncFlags">
      <MemberSignature Language="C#" Value="public static bool TryToMsyncFlags (int value, out Mono.Unix.Native.MsyncFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.MsyncFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MsyncFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToMsyncFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.MsyncFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMsyncFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToMsyncFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.MsyncFlags ToMsyncFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.MsyncFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.MsyncFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromMsyncFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToMsyncFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromOpenFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromOpenFlags (Mono.Unix.Native.OpenFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.OpenFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.OpenFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToOpenFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromOpenFlags">
      <MemberSignature Language="C#" Value="public static int FromOpenFlags (Mono.Unix.Native.OpenFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.OpenFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.OpenFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToOpenFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToOpenFlags">
      <MemberSignature Language="C#" Value="public static bool TryToOpenFlags (int value, out Mono.Unix.Native.OpenFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.OpenFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.OpenFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToOpenFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.OpenFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromOpenFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToOpenFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.OpenFlags ToOpenFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.OpenFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.OpenFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromOpenFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToOpenFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromPathconfName">
      <MemberSignature Language="C#" Value="public static bool TryFromPathconfName (Mono.Unix.Native.PathconfName value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PathconfName" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PathconfName" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPathconfName" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPathconfName" />
      </Docs>
    </Member>
    <Member MemberName="FromPathconfName">
      <MemberSignature Language="C#" Value="public static int FromPathconfName (Mono.Unix.Native.PathconfName value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PathconfName" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PathconfName" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPathconfName" />
      </Docs>
    </Member>
    <Member MemberName="TryToPathconfName">
      <MemberSignature Language="C#" Value="public static bool TryToPathconfName (int value, out Mono.Unix.Native.PathconfName rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.PathconfName&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PathconfName" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToPathconfName" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.PathconfName" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPathconfName" />
      </Docs>
    </Member>
    <Member MemberName="ToPathconfName">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.PathconfName ToPathconfName (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.PathconfName</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PathconfName" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPathconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPathconfName" />
      </Docs>
    </Member>
    <Member MemberName="TryFromPollEvents">
      <MemberSignature Language="C#" Value="public static bool TryFromPollEvents (Mono.Unix.Native.PollEvents value, out short rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PollEvents" />
        <Parameter Name="rval" Type="System.Int16&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PollEvents" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPollEvents" />
      </Docs>
    </Member>
    <Member MemberName="FromPollEvents">
      <MemberSignature Language="C#" Value="public static short FromPollEvents (Mono.Unix.Native.PollEvents value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int16</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PollEvents" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PollEvents" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPollEvents" />
      </Docs>
    </Member>
    <Member MemberName="TryToPollEvents">
      <MemberSignature Language="C#" Value="public static bool TryToPollEvents (short value, out Mono.Unix.Native.PollEvents rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
        <Parameter Name="rval" Type="Mono.Unix.Native.PollEvents&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PollEvents" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToPollEvents" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.PollEvents" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPollEvents" />
      </Docs>
    </Member>
    <Member MemberName="ToPollEvents">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.PollEvents ToPollEvents (short value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.PollEvents</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PollEvents" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPollEvents" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPollEvents" />
      </Docs>
    </Member>
    <Member MemberName="TryFromPosixFadviseAdvice">
      <MemberSignature Language="C#" Value="public static bool TryFromPosixFadviseAdvice (Mono.Unix.Native.PosixFadviseAdvice value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PosixFadviseAdvice" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PosixFadviseAdvice" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPosixFadviseAdvice" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixFadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="FromPosixFadviseAdvice">
      <MemberSignature Language="C#" Value="public static int FromPosixFadviseAdvice (Mono.Unix.Native.PosixFadviseAdvice value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PosixFadviseAdvice" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PosixFadviseAdvice" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixFadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="TryToPosixFadviseAdvice">
      <MemberSignature Language="C#" Value="public static bool TryToPosixFadviseAdvice (int value, out Mono.Unix.Native.PosixFadviseAdvice rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.PosixFadviseAdvice&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PosixFadviseAdvice" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToPosixFadviseAdvice" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.PosixFadviseAdvice" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixFadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="ToPosixFadviseAdvice">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.PosixFadviseAdvice ToPosixFadviseAdvice (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.PosixFadviseAdvice</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PosixFadviseAdvice" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixFadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixFadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="TryFromPosixMadviseAdvice">
      <MemberSignature Language="C#" Value="public static bool TryFromPosixMadviseAdvice (Mono.Unix.Native.PosixMadviseAdvice value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PosixMadviseAdvice" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PosixMadviseAdvice" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromPosixMadviseAdvice" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixMadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="FromPosixMadviseAdvice">
      <MemberSignature Language="C#" Value="public static int FromPosixMadviseAdvice (Mono.Unix.Native.PosixMadviseAdvice value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.PosixMadviseAdvice" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.PosixMadviseAdvice" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixMadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="TryToPosixMadviseAdvice">
      <MemberSignature Language="C#" Value="public static bool TryToPosixMadviseAdvice (int value, out Mono.Unix.Native.PosixMadviseAdvice rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.PosixMadviseAdvice&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PosixMadviseAdvice" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToPosixMadviseAdvice" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.PosixMadviseAdvice" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixMadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="ToPosixMadviseAdvice">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.PosixMadviseAdvice ToPosixMadviseAdvice (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.PosixMadviseAdvice</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.PosixMadviseAdvice" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromPosixMadviseAdvice" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToPosixMadviseAdvice" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSeekFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromSeekFlags (Mono.Unix.Native.SeekFlags value, out short rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SeekFlags" />
        <Parameter Name="rval" Type="System.Int16&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SeekFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSeekFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSeekFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromSeekFlags">
      <MemberSignature Language="C#" Value="public static short FromSeekFlags (Mono.Unix.Native.SeekFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int16</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SeekFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SeekFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSeekFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToSeekFlags">
      <MemberSignature Language="C#" Value="public static bool TryToSeekFlags (short value, out Mono.Unix.Native.SeekFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
        <Parameter Name="rval" Type="Mono.Unix.Native.SeekFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SeekFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSeekFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.SeekFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSeekFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToSeekFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.SeekFlags ToSeekFlags (short value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.SeekFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SeekFlags" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSeekFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSeekFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSignum">
      <MemberSignature Language="C#" Value="public static bool TryFromSignum (Mono.Unix.Native.Signum value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.Signum" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.Signum" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSignum" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSignum" />
      </Docs>
    </Member>
    <Member MemberName="FromSignum">
      <MemberSignature Language="C#" Value="public static int FromSignum (Mono.Unix.Native.Signum value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.Signum" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.Signum" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSignum" />
      </Docs>
    </Member>
    <Member MemberName="TryToSignum">
      <MemberSignature Language="C#" Value="public static bool TryToSignum (int value, out Mono.Unix.Native.Signum rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.Signum&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.Signum" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSignum" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.Signum" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSignum" />
      </Docs>
    </Member>
    <Member MemberName="ToSignum">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.Signum ToSignum (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.Signum</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.Signum" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSignum" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSignum" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSysconfName">
      <MemberSignature Language="C#" Value="public static bool TryFromSysconfName (Mono.Unix.Native.SysconfName value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SysconfName" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SysconfName" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSysconfName" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSysconfName" />
      </Docs>
    </Member>
    <Member MemberName="FromSysconfName">
      <MemberSignature Language="C#" Value="public static int FromSysconfName (Mono.Unix.Native.SysconfName value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SysconfName" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SysconfName" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSysconfName" />
      </Docs>
    </Member>
    <Member MemberName="TryToSysconfName">
      <MemberSignature Language="C#" Value="public static bool TryToSysconfName (int value, out Mono.Unix.Native.SysconfName rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.SysconfName&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SysconfName" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSysconfName" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.SysconfName" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSysconfName" />
      </Docs>
    </Member>
    <Member MemberName="ToSysconfName">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.SysconfName ToSysconfName (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.SysconfName</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SysconfName" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSysconfName" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSysconfName" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSyslogFacility">
      <MemberSignature Language="C#" Value="public static bool TryFromSyslogFacility (Mono.Unix.Native.SyslogFacility value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogFacility" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogFacility" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSyslogFacility" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogFacility" />
      </Docs>
    </Member>
    <Member MemberName="FromSyslogFacility">
      <MemberSignature Language="C#" Value="public static int FromSyslogFacility (Mono.Unix.Native.SyslogFacility value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogFacility" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogFacility" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogFacility" />
      </Docs>
    </Member>
    <Member MemberName="TryToSyslogFacility">
      <MemberSignature Language="C#" Value="public static bool TryToSyslogFacility (int value, out Mono.Unix.Native.SyslogFacility rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.SyslogFacility&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogFacility" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSyslogFacility" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.SyslogFacility" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogFacility" />
      </Docs>
    </Member>
    <Member MemberName="ToSyslogFacility">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.SyslogFacility ToSyslogFacility (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.SyslogFacility</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogFacility" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogFacility" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogFacility" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSyslogLevel">
      <MemberSignature Language="C#" Value="public static bool TryFromSyslogLevel (Mono.Unix.Native.SyslogLevel value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogLevel" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogLevel" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSyslogLevel" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogLevel" />
      </Docs>
    </Member>
    <Member MemberName="FromSyslogLevel">
      <MemberSignature Language="C#" Value="public static int FromSyslogLevel (Mono.Unix.Native.SyslogLevel value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogLevel" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogLevel" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogLevel" />
      </Docs>
    </Member>
    <Member MemberName="TryToSyslogLevel">
      <MemberSignature Language="C#" Value="public static bool TryToSyslogLevel (int value, out Mono.Unix.Native.SyslogLevel rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.SyslogLevel&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogLevel" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSyslogLevel" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.SyslogLevel" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogLevel" />
      </Docs>
    </Member>
    <Member MemberName="ToSyslogLevel">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.SyslogLevel ToSyslogLevel (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.SyslogLevel</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogLevel" />.</summary>
        <returns>The equivalent managed value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent managed value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogLevel" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogLevel" />
      </Docs>
    </Member>
    <Member MemberName="TryFromSyslogOptions">
      <MemberSignature Language="C#" Value="public static bool TryFromSyslogOptions (Mono.Unix.Native.SyslogOptions value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogOptions" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogOptions" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogOptions" />
      </Docs>
    </Member>
    <Member MemberName="FromSyslogOptions">
      <MemberSignature Language="C#" Value="public static int FromSyslogOptions (Mono.Unix.Native.SyslogOptions value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.SyslogOptions" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.SyslogOptions" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogOptions" />
      </Docs>
    </Member>
    <Member MemberName="TryToSyslogOptions">
      <MemberSignature Language="C#" Value="public static bool TryToSyslogOptions (int value, out Mono.Unix.Native.SyslogOptions rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.SyslogOptions&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogOptions" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToSyslogOptions" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.SyslogOptions" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogOptions" />
      </Docs>
    </Member>
    <Member MemberName="ToSyslogOptions">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.SyslogOptions ToSyslogOptions (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.SyslogOptions</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.SyslogOptions" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromSyslogOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToSyslogOptions" />
      </Docs>
    </Member>
    <Member MemberName="TryFromWaitOptions">
      <MemberSignature Language="C#" Value="public static bool TryFromWaitOptions (Mono.Unix.Native.WaitOptions value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.WaitOptions" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.WaitOptions" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToWaitOptions" />
      </Docs>
    </Member>
    <Member MemberName="FromWaitOptions">
      <MemberSignature Language="C#" Value="public static int FromWaitOptions (Mono.Unix.Native.WaitOptions value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.WaitOptions" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.WaitOptions" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToWaitOptions" />
      </Docs>
    </Member>
    <Member MemberName="TryToWaitOptions">
      <MemberSignature Language="C#" Value="public static bool TryToWaitOptions (int value, out Mono.Unix.Native.WaitOptions rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.WaitOptions&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.WaitOptions" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToWaitOptions" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.WaitOptions" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromWaitOptions" />
      </Docs>
    </Member>
    <Member MemberName="ToWaitOptions">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.WaitOptions ToWaitOptions (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.WaitOptions</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.WaitOptions" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromWaitOptions" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToWaitOptions" />
      </Docs>
    </Member>
    <Member MemberName="TryFromXattrFlags">
      <MemberSignature Language="C#" Value="public static bool TryFromXattrFlags (Mono.Unix.Native.XattrFlags value, out int rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.XattrFlags" />
        <Parameter Name="rval" Type="System.Int32&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <param name="rval">The OS-specific equivalent value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.XattrFlags" /> 
          enumeration value to an OS-specific value.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />.</para>
          <para>If successful, this method stores the OS-specific equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain <c>0</c>.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToXattrFlags" />
      </Docs>
    </Member>
    <Member MemberName="FromXattrFlags">
      <MemberSignature Language="C#" Value="public static int FromXattrFlags (Mono.Unix.Native.XattrFlags value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.XattrFlags" />
      </Parameters>
      <Docs>
        <param name="value">The managed value to convert.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.XattrFlags" /> 
          to an OS-specific value.</summary>
        <returns>The equivalent OS-specific value.</returns>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="value" /> has no equivalent OS-specific value.
        </exception>
        <remarks>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToXattrFlags" />
      </Docs>
    </Member>
    <Member MemberName="TryToXattrFlags">
      <MemberSignature Language="C#" Value="public static bool TryToXattrFlags (int value, out Mono.Unix.Native.XattrFlags rval);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
        <Parameter Name="rval" Type="Mono.Unix.Native.XattrFlags&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <param name="rval">The managed equivalent value</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.XattrFlags" />.</summary>
        <returns>
          <see langword="true" /> if the conversion was successful; 
        otherwise, <see langword="false" />.</returns>
        <remarks>
          <para>This is an exception-safe alternative to 
        <see cref="M:Mono.Unix.Native.NativeConvert.ToXattrFlags" />.</para>
          <para>If successful, this method stores the managed equivalent
        value of <paramref name="value" /> into <paramref name="rval" />.
        Otherwise, <paramref name="rval" /> will contain a <c>0</c>
        cast to a <see cref="T:Mono.Unix.Native.XattrFlags" />.</para>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromXattrFlags" />
      </Docs>
    </Member>
    <Member MemberName="ToXattrFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.XattrFlags ToXattrFlags (int value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.XattrFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">The OS-specific value to convert.</param>
        <summary>Converts an OS-specific value to a 
          <see cref="T:Mono.Unix.Native.XattrFlags" />.</summary>
        <returns>An approximation of the equivalent managed value.</returns>
        <remarks>
          <para>The current conversion functions are unable to determine
        if a value in a <c>[Flags]</c>-marked enumeration <i>does not</i> 
        exist on the current platform.  As such, if <paramref name="value" /> 
        contains a flag value which the current platform doesn't support, it 
        will not be present in the managed value returned.</para>
          <para>This should only be a problem if <paramref name="value" /><i>was not</i> previously returned by 
        <see cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />.</para>
        </remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryFromXattrFlags" />
        <altmember cref="M:Mono.Unix.Native.NativeConvert.TryToXattrFlags" />
      </Docs>
    </Member>
    <!-- END GENERATED CONTENT -->
    <Member MemberName="LocalUnixEpoch">
      <MemberSignature Language="C#" Value="public static readonly DateTime LocalUnixEpoch = 1/1/1970 12:00:00 AM;" />
      <MemberType>Field</MemberType>
      <ReturnValue>
        <ReturnType>System.DateTime</ReturnType>
      </ReturnValue>
      <MemberValue>1/1/1970 12:00:00 AM</MemberValue>
      <Docs>
        <summary>The start of the Unix epoch.</summary>
        <remarks>This <c>DateTime</c> corresponds to a 
        Unix <c>time_t</c> value of 0.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToDateTime">
      <MemberSignature Language="C#" Value="public static DateTime ToDateTime (long time);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.DateTime</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="time" Type="System.Int64" />
      </Parameters>
      <Docs>
        <param name="time">A Unix <c>time_t</c> value.</param>
        <summary>Converts a Unix <c>time_t</c> in the user's current time zone 
        into a <see cref="T:System.DateTime" />.</summary>
        <returns>The converted <c>time_t</c>.</returns>
        <remarks>A Unix <c>time_t</c> stores the number of seconds that have
        elapsed since Midnight of January 1, 1970, UTC.</remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromTimeT" />
      </Docs>
    </Member>
    <Member MemberName="FromDateTime">
      <MemberSignature Language="C#" Value="public static long FromDateTime (DateTime time);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="time" Type="System.DateTime" />
      </Parameters>
      <Docs>
        <param name="time">A <see cref="T:System.DateTime" /> in the user's
        current time zone.</param>
        <summary>Converts a <see cref="T:System.DateTime" /> into a Unix
        <c>time_t</c>.</summary>
        <returns>The converted <see cref="T:System.DateTime" /></returns>
        <remarks>A Unix <c>time_t</c> stores the number of seconds that have
        elapsed since Midnight of January 1, 1970, UTC.</remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToTimeT" />
      </Docs>
    </Member>
    <Member MemberName="FromTimeT">
      <MemberSignature Language="C#" Value="public static DateTime FromTimeT (long time);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.DateTime</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="time" Type="System.Int64" />
      </Parameters>
      <Docs>
        <param name="time">A Unix <c>time_t</c> value.</param>
        <summary>Converts a Unix <c>time_t</c> in the user's current time zone 
        into a <see cref="T:System.DateTime" />.</summary>
        <returns>The converted <c>time_t</c>.</returns>
        <remarks>A Unix <c>time_t</c> stores the number of seconds that have
        elapsed since Midnight of January 1, 1970, UTC.</remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.ToDateTime" />
      </Docs>
    </Member>
    <Member MemberName="ToTimeT">
      <MemberSignature Language="C#" Value="public static long ToTimeT (DateTime time);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="time" Type="System.DateTime" />
      </Parameters>
      <Docs>
        <param name="time">A <see cref="T:System.DateTime" /> in the user's
        current time zone.</param>
        <summary>Converts a <see cref="T:System.DateTime" /> into a Unix
        <c>time_t</c>.</summary>
        <returns>The converted <see cref="T:System.DateTime" /></returns>
        <remarks>A Unix <c>time_t</c> stores the number of seconds that have
        elapsed since Midnight of January 1, 1970, UTC.</remarks>
        <altmember cref="M:Mono.Unix.Native.NativeConvert.FromDateTime" />
      </Docs>
    </Member>
    <Member MemberName="ToOpenFlags">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.OpenFlags ToOpenFlags (System.IO.FileMode mode, System.IO.FileAccess access);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.OpenFlags</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="mode" Type="System.IO.FileMode" />
        <Parameter Name="access" Type="System.IO.FileAccess" />
      </Parameters>
      <Docs>
        <param name="mode">Specifies how to open the file</param>
        <param name="access">Specifies what can be done to the file.</param>
        <summary>Converts the managed 
        <c>(<see cref="T:System.IO.FileMode" /><see cref="T:System.IO.FileAccess" />)</c> pair into a
        <see cref="T:Mono.Unix.Native.OpenFlags" /></summary>
        <returns>The morally equivalent file flags.</returns>
        <remarks>This is primarily useful if you're trying to make a
        Unix-specific API look like a <c>CLI</c> API, such as with 
        <see cref="T:Mono.Unix.UnixStream" />.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToFopenMode">
      <MemberSignature Language="C#" Value="public static string ToFopenMode (System.IO.FileAccess access);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="access" Type="System.IO.FileAccess" />
      </Parameters>
      <Docs>
        <param name="access">Specifies what can be done to the file.</param>
        <summary>Converts the managed 
        <see cref="T:System.IO.FileAccess" /> into a
        string suitable for use with
        <see cref="M:Mono.Unix.Native.Stdlib.fopen" />'s 
        <paramref name="mode" /> parameter..</summary>
        <returns>The morally equivalent file mode.</returns>
        <remarks>This is primarily useful if you're trying to make a
        Unix-specific API look like a <c>CLI</c> API, such as with 
        <see cref="T:Mono.Unix.StdioFileStream" />.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToFopenMode">
      <MemberSignature Language="C#" Value="public static string ToFopenMode (System.IO.FileMode mode);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="mode" Type="System.IO.FileMode" />
      </Parameters>
      <Docs>
        <param name="mode">Specifies how to open the file</param>
        <summary>Converts the managed 
        <see cref="T:System.IO.FileMode" /> into a
        string suitable for use with
        <see cref="M:Mono.Unix.Native.Stdlib.fopen" />'s 
        <paramref name="mode" /> parameter..</summary>
        <returns>The morally equivalent file mode.</returns>
        <remarks>This is primarily useful if you're trying to make a
        Unix-specific API look like a <c>CLI</c> API, such as with 
        <see cref="T:Mono.Unix.StdioFileStream" />.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToFopenMode">
      <MemberSignature Language="C#" Value="public static string ToFopenMode (System.IO.FileMode mode, System.IO.FileAccess access);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="mode" Type="System.IO.FileMode" />
        <Parameter Name="access" Type="System.IO.FileAccess" />
      </Parameters>
      <Docs>
        <param name="mode">Specifies how to open the file</param>
        <param name="access">Specifies what can be done to the file.</param>
        <summary>Converts the managed 
        <c>(<see cref="T:System.IO.FileMode" /><see cref="T:System.IO.FileAccess" />)</c> pair into a
        string suitable for use with
        <see cref="M:Mono.Unix.Native.Stdlib.fopen" />'s 
        <paramref name="mode" /> parameter..</summary>
        <returns>The morally equivalent file mode.</returns>
        <remarks>This is primarily useful if you're trying to make a
        Unix-specific API look like a <c>CLI</c> API, such as with 
        <see cref="T:Mono.Unix.StdioFileStream" />.</remarks>
      </Docs>
    </Member>
    <Member MemberName="FromOctalPermissionString">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.FilePermissions FromOctalPermissionString (string value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.FilePermissions</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="value">The octal representation of a 
        <see cref="T:Mono.Unix.Native.FilePermissions" /> value.</param>
        <summary>Converts an octal string representation of a 
        <see cref="T:Mono.Unix.Native.FilePermissions" /> into a 
        <see cref="T:Mono.Unix.Native.FilePermissions" />.</summary>
        <returns>The converted 
        <see cref="T:Mono.Unix.Native.FilePermissions" />.</returns>
        <remarks>
          <para>This method makes it easier to create a 
          <see cref="T:Mono.Unix.Native.FilePermissions" /> value, allowing 
          the use of common octal permission notation.</para>
          <example>
            <code lang="C#">
using System;
using Mono.Unix.Native;

class Test
{
	public static void Main(string[] args)
	{
		// these two statements are equivalent.
		FilePermissions simple = NativeConvert.FromOctalPermissionString ("0644");
		FilePermissions annoying = 
			FilePermissions.S_IRUSR | FilePermissions.S_IWUSR | 
			FilePermissions.S_IRGRP | 
			FilePermissions.S_IROTH;
	}
}
  </code>
          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="ToOctalPermissionString">
      <MemberSignature Language="C#" Value="public static string ToOctalPermissionString (Mono.Unix.Native.FilePermissions value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FilePermissions" />
      </Parameters>
      <Docs>
        <param name="value">A Unix <c>mode_t</c> value.</param>
        <summary>Converts a <see cref="T:Mono.Unix.Native.FilePermissions" /> 
        into an octal string representation.</summary>
        <returns>An octal string representation of a Unix <c>mode_t</c>.</returns>
        <remarks>
          <example>
            <code lang="C#">
using System;
using Mono.Unix.Native;

class Test
{
	public static void Main(string[] args)
	{
		foreach (string file in args) {
			Stat stat;
			if (Syscall.stat (file, out stat) == 0) {
				Console.WriteLine ("  File: `{0}'", file);
				Console.WriteLine ("Access: ({0}/{1})", 
					NativeConvert.ToOctalPermissionString (stat.st_mode),
					NativeConvert.ToUnixPermissionString (stat.st_mode))
			}
			else {
				Console.WriteLine ("Cannot stat `{0}': {1}", file,
					Stdlib.strerror (Stdlib.GetLastError ()));
			}
		}
	}
}
  </code>
          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="FromUnixPermissionString">
      <MemberSignature Language="C#" Value="public static Mono.Unix.Native.FilePermissions FromUnixPermissionString (string value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>Mono.Unix.Native.FilePermissions</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="value">The unix permission representation of a 
        <see cref="T:Mono.Unix.Native.FilePermissions" /> value.</param>
        <summary>Converts a unix permission representation of a 
        <see cref="T:Mono.Unix.Native.FilePermissions" /> into a 
        <see cref="T:Mono.Unix.Native.FilePermissions" />.</summary>
        <returns>The converted 
        <see cref="T:Mono.Unix.Native.FilePermissions" />.</returns>
        <remarks>
          <para>A "Unix permission string" is the 9 or 10 character string
          commonly seen in the output of <c>ls -l</c>, e.g.
          "<c>-rwxr-x---</c>".</para>
          <para>This method makes it easier to create a 
          <see cref="T:Mono.Unix.Native.FilePermissions" /> value, allowing 
          the use of common Unix permission notation.</para>
          <para>Both 9 and 10 character representations are decoded, the
          difference being the file type.</para>
          <example>
            <code lang="C#">
using System;
using Mono.Unix.Native;

class Test
{
	public static void Main(string[] args)
	{
		// All statement pairs are equivalent.

		// Note: 9 character string -- file type not set
		FilePermissions simple1 = NativeConvert.FromUnixPermissionString ("rw-r--r--");
		FilePermissions annoying1 = 
			FilePermissions.S_IRUSR | FilePermissions.S_IWUSR | 
			FilePermissions.S_IRGRP | 
			FilePermissions.S_IROTH;

		// Note: 10 character string -- regular file specified
		FilePermissions simple2 = NativeConvert.FromUnixPermissionString ("----------");
		FilePermissions annoying2 = FilePermissions.S_IFREG;

		// Note: 10 character string -- directory with all access permissions specified
		FilePermissions simple3 = NativeConvert.FromUnixPermissionString ("drwxrwxrwx");
		FilePermissions annoying3 = FilePermissions.S_IFDIR |
			FilePermissions.ACCESSPERMS;
	}
}
  </code>
          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="ToUnixPermissionString">
      <MemberSignature Language="C#" Value="public static string ToUnixPermissionString (Mono.Unix.Native.FilePermissions value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="Mono.Unix.Native.FilePermissions" />
      </Parameters>
      <Docs>
        <param name="value">
          <see cref="Mono.Unix.Native.FilePermissions" /> to convert.</param>
        <summary>Converts a <see cref="Mono.Unix.Native.FilePermissions" /> into a Unix permission string.</summary>
        <returns>A Unix permission string.</returns>
        <remarks>
          <para>A "Unix permission string" is the 9 or 10 character string
          commonly seen in the output of <c>ls -l</c>, e.g.
          "<c>-rwxr-x---</c>".</para>
          <para>Both 9 and 10 character representations are encoded, the
          difference being the file type.  If a file type is specified, a 10
          character string is returned, with the file type encoded in the
          first character.  Otherwise a 9 character string is returned.</para>
          <example>
            <code lang="C#">
using System;
using Mono.Unix.Native;

class Test
{
	public static void Main(string[] args)
	{
		foreach (string file in args) {
			Stat stat;
			if (Syscall.stat (file, out stat) == 0) {
				Console.WriteLine ("  File: `{0}'", file);
				Console.WriteLine ("Access: ({0}/{1})", 
					NativeConvert.ToOctalPermissionString (stat.st_mode),
					NativeConvert.ToUnixPermissionString (stat.st_mode))
			}
			else {
				Console.WriteLine ("Cannot stat `{0}': {1}", file,
					Stdlib.strerror (Stdlib.GetLastError ()));
			}
		}
	}
}
  </code>
          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="LocalUtcOffset">
      <MemberSignature Language="C#" Value="public static readonly TimeSpan LocalUtcOffset;" />
      <MemberType>Field</MemberType>
      <ReturnValue>
        <ReturnType>System.TimeSpan</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (ref Mono.Unix.Native.Pollfd source, IntPtr destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="Mono.Unix.Native.Pollfd&amp;" RefType="ref" />
        <Parameter Name="destination" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (ref Mono.Unix.Native.Stat source, IntPtr destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="Mono.Unix.Native.Stat&amp;" RefType="ref" />
        <Parameter Name="destination" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (ref Mono.Unix.Native.Statvfs source, IntPtr destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="Mono.Unix.Native.Statvfs&amp;" RefType="ref" />
        <Parameter Name="destination" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (ref Mono.Unix.Native.Timeval source, IntPtr destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="Mono.Unix.Native.Timeval&amp;" RefType="ref" />
        <Parameter Name="destination" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (ref Mono.Unix.Native.Timezone source, IntPtr destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="Mono.Unix.Native.Timezone&amp;" RefType="ref" />
        <Parameter Name="destination" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (IntPtr source, out Mono.Unix.Native.Pollfd destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="System.IntPtr" />
        <Parameter Name="destination" Type="Mono.Unix.Native.Pollfd&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (IntPtr source, out Mono.Unix.Native.Stat destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="System.IntPtr" />
        <Parameter Name="destination" Type="Mono.Unix.Native.Stat&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (IntPtr source, out Mono.Unix.Native.Statvfs destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="System.IntPtr" />
        <Parameter Name="destination" Type="Mono.Unix.Native.Statvfs&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (IntPtr source, out Mono.Unix.Native.Timeval destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="System.IntPtr" />
        <Parameter Name="destination" Type="Mono.Unix.Native.Timeval&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryCopy">
      <MemberSignature Language="C#" Value="public static bool TryCopy (IntPtr source, out Mono.Unix.Native.Timezone destination);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="source" Type="System.IntPtr" />
        <Parameter Name="destination" Type="Mono.Unix.Native.Timezone&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="source">To be added.</param>
        <param name="destination">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
  </Members>
  <Docs>
    <summary>Performs conversions between managed and unmanaged enumeration
    values.</summary>
    <remarks>
      <para>Different operating systems give different values to the same
    identifier.  For example, <c>SIGBUS</c> is 10 under FreeBSD, while it's 7 
    for x86 Linux.  Meanwhile, <see cref="F:Mono.Unix.Native.Signum.SIGBUS" /> will 
    have the same value everywhere.  Since it is undesirable to require
    recompilation for every target platform, the <see cref="N:Mono.Unix.Native" />
    namespace instead exports a stable
    ABI, and provides conversion functions to convert between the managed 
    and appropriate OS-specific values.</para>
      <para>Normally this conversion is handled transparently by the 
    wrapper functions, so members of this class shouldn't need to be used.</para>
      <block subset="none" type="note">
        <para>You cannot blindly cast a value to an enumeration without
      sacrificing portability, as the platform may not support the value you
      want.
      </para>
      </block>
    </remarks>
  </Docs>
  <Attributes>
    <Attribute>
      <AttributeName>System.CLSCompliant(false)</AttributeName>
    </Attribute>
  </Attributes>
</Type>
