mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs

   1 /*
   2  * This file was automatically generated by create-native-map from ./../../class/lib/net_4_x/Mono.Posix.dll.
   3  *
   4  * DO NOT MODIFY.
   5  */
   6
   7 using System;
   8 using System.Runtime.InteropServices;
   9 using Mono.Unix.Native;
  10
  11 namespace Mono.Unix.Native {
  12
  13         public sealed /* static */ partial class NativeConvert
  14         {
  15                 private NativeConvert () {}
  16
  17                 private const string LIB = "MonoPosixHelper";
  18
  19                 private static void ThrowArgumentException (object value)
  20                 {
  21                         throw new ArgumentOutOfRangeException ("value", value,
  22                                 Locale.GetText ("Current platform doesn't support this value."));
  23                 }
  24
  25                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAccessModes")]
  26                 private static extern int FromAccessModes (AccessModes value, out Int32 rval);
  27
  28                 public static bool TryFromAccessModes (AccessModes value, out Int32 rval)
  29                 {
  30                         return FromAccessModes (value, out rval) == 0;
  31                 }
  32
  33                 public static Int32 FromAccessModes (AccessModes value)
  34                 {
  35                         Int32 rval;
  36                         if (FromAccessModes (value, out rval) == -1)
  37                                 ThrowArgumentException (value);
  38                         return rval;
  39                 }
  40
  41                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessModes")]
  42                 private static extern int ToAccessModes (Int32 value, out AccessModes rval);
  43
  44                 public static bool TryToAccessModes (Int32 value, out AccessModes rval)
  45                 {
  46                         return ToAccessModes (value, out rval) == 0;
  47                 }
  48
  49                 public static AccessModes ToAccessModes (Int32 value)
  50                 {
  51                         AccessModes rval;
  52                         if (ToAccessModes (value, out rval) == -1)
  53                                 ThrowArgumentException (value);
  54                         return rval;
  55                 }
  56
  57                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAtFlags")]
  58                 private static extern int FromAtFlags (AtFlags value, out Int32 rval);
  59
  60                 public static bool TryFromAtFlags (AtFlags value, out Int32 rval)
  61                 {
  62                         return FromAtFlags (value, out rval) == 0;
  63                 }
  64
  65                 public static Int32 FromAtFlags (AtFlags value)
  66                 {
  67                         Int32 rval;
  68                         if (FromAtFlags (value, out rval) == -1)
  69                                 ThrowArgumentException (value);
  70                         return rval;
  71                 }
  72
  73                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAtFlags")]
  74                 private static extern int ToAtFlags (Int32 value, out AtFlags rval);
  75
  76                 public static bool TryToAtFlags (Int32 value, out AtFlags rval)
  77                 {
  78                         return ToAtFlags (value, out rval) == 0;
  79                 }
  80
  81                 public static AtFlags ToAtFlags (Int32 value)
  82                 {
  83                         AtFlags rval;
  84                         if (ToAtFlags (value, out rval) == -1)
  85                                 ThrowArgumentException (value);
  86                         return rval;
  87                 }
  88
  89                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfstrName")]
  90                 private static extern int FromConfstrName (ConfstrName value, out Int32 rval);
  91
  92                 public static bool TryFromConfstrName (ConfstrName value, out Int32 rval)
  93                 {
  94                         return FromConfstrName (value, out rval) == 0;
  95                 }
  96
  97                 public static Int32 FromConfstrName (ConfstrName value)
  98                 {
  99                         Int32 rval;
 100                         if (FromConfstrName (value, out rval) == -1)
 101                                 ThrowArgumentException (value);
 102                         return rval;
 103                 }
 104
 105                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfstrName")]
 106                 private static extern int ToConfstrName (Int32 value, out ConfstrName rval);
 107
 108                 public static bool TryToConfstrName (Int32 value, out ConfstrName rval)
 109                 {
 110                         return ToConfstrName (value, out rval) == 0;
 111                 }
 112
 113                 public static ConfstrName ToConfstrName (Int32 value)
 114                 {
 115                         ConfstrName rval;
 116                         if (ToConfstrName (value, out rval) == -1)
 117                                 ThrowArgumentException (value);
 118                         return rval;
 119                 }
 120
 121                 [DllImport (LIB, EntryPoint="Mono_Posix_FromDirectoryNotifyFlags")]
 122                 private static extern int FromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval);
 123
 124                 public static bool TryFromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval)
 125                 {
 126                         return FromDirectoryNotifyFlags (value, out rval) == 0;
 127                 }
 128
 129                 public static Int32 FromDirectoryNotifyFlags (DirectoryNotifyFlags value)
 130                 {
 131                         Int32 rval;
 132                         if (FromDirectoryNotifyFlags (value, out rval) == -1)
 133                                 ThrowArgumentException (value);
 134                         return rval;
 135                 }
 136
 137                 [DllImport (LIB, EntryPoint="Mono_Posix_ToDirectoryNotifyFlags")]
 138                 private static extern int ToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval);
 139
 140                 public static bool TryToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval)
 141                 {
 142                         return ToDirectoryNotifyFlags (value, out rval) == 0;
 143                 }
 144
 145                 public static DirectoryNotifyFlags ToDirectoryNotifyFlags (Int32 value)
 146                 {
 147                         DirectoryNotifyFlags rval;
 148                         if (ToDirectoryNotifyFlags (value, out rval) == -1)
 149                                 ThrowArgumentException (value);
 150                         return rval;
 151                 }
 152
 153                 [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollEvents")]
 154                 private static extern int FromEpollEvents (EpollEvents value, out UInt32 rval);
 155
 156                 public static bool TryFromEpollEvents (EpollEvents value, out UInt32 rval)
 157                 {
 158                         return FromEpollEvents (value, out rval) == 0;
 159                 }
 160
 161                 public static UInt32 FromEpollEvents (EpollEvents value)
 162                 {
 163                         UInt32 rval;
 164                         if (FromEpollEvents (value, out rval) == -1)
 165                                 ThrowArgumentException (value);
 166                         return rval;
 167                 }
 168
 169                 [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollEvents")]
 170                 private static extern int ToEpollEvents (UInt32 value, out EpollEvents rval);
 171
 172                 public static bool TryToEpollEvents (UInt32 value, out EpollEvents rval)
 173                 {
 174                         return ToEpollEvents (value, out rval) == 0;
 175                 }
 176
 177                 public static EpollEvents ToEpollEvents (UInt32 value)
 178                 {
 179                         EpollEvents rval;
 180                         if (ToEpollEvents (value, out rval) == -1)
 181                                 ThrowArgumentException (value);
 182                         return rval;
 183                 }
 184
 185                 [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollFlags")]
 186                 private static extern int FromEpollFlags (EpollFlags value, out Int32 rval);
 187
 188                 public static bool TryFromEpollFlags (EpollFlags value, out Int32 rval)
 189                 {
 190                         return FromEpollFlags (value, out rval) == 0;
 191                 }
 192
 193                 public static Int32 FromEpollFlags (EpollFlags value)
 194                 {
 195                         Int32 rval;
 196                         if (FromEpollFlags (value, out rval) == -1)
 197                                 ThrowArgumentException (value);
 198                         return rval;
 199                 }
 200
 201                 [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollFlags")]
 202                 private static extern int ToEpollFlags (Int32 value, out EpollFlags rval);
 203
 204                 public static bool TryToEpollFlags (Int32 value, out EpollFlags rval)
 205                 {
 206                         return ToEpollFlags (value, out rval) == 0;
 207                 }
 208
 209                 public static EpollFlags ToEpollFlags (Int32 value)
 210                 {
 211                         EpollFlags rval;
 212                         if (ToEpollFlags (value, out rval) == -1)
 213                                 ThrowArgumentException (value);
 214                         return rval;
 215                 }
 216
 217                 [DllImport (LIB, EntryPoint="Mono_Posix_FromErrno")]
 218                 private static extern int FromErrno (Errno value, out Int32 rval);
 219
 220                 public static bool TryFromErrno (Errno value, out Int32 rval)
 221                 {
 222                         return FromErrno (value, out rval) == 0;
 223                 }
 224
 225                 public static Int32 FromErrno (Errno value)
 226                 {
 227                         Int32 rval;
 228                         if (FromErrno (value, out rval) == -1)
 229                                 ThrowArgumentException (value);
 230                         return rval;
 231                 }
 232
 233                 [DllImport (LIB, EntryPoint="Mono_Posix_ToErrno")]
 234                 private static extern int ToErrno (Int32 value, out Errno rval);
 235
 236                 public static bool TryToErrno (Int32 value, out Errno rval)
 237                 {
 238                         return ToErrno (value, out rval) == 0;
 239                 }
 240
 241                 public static Errno ToErrno (Int32 value)
 242                 {
 243                         Errno rval;
 244                         if (ToErrno (value, out rval) == -1)
 245                                 ThrowArgumentException (value);
 246                         return rval;
 247                 }
 248
 249                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFcntlCommand")]
 250                 private static extern int FromFcntlCommand (FcntlCommand value, out Int32 rval);
 251
 252                 public static bool TryFromFcntlCommand (FcntlCommand value, out Int32 rval)
 253                 {
 254                         return FromFcntlCommand (value, out rval) == 0;
 255                 }
 256
 257                 public static Int32 FromFcntlCommand (FcntlCommand value)
 258                 {
 259                         Int32 rval;
 260                         if (FromFcntlCommand (value, out rval) == -1)
 261                                 ThrowArgumentException (value);
 262                         return rval;
 263                 }
 264
 265                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFcntlCommand")]
 266                 private static extern int ToFcntlCommand (Int32 value, out FcntlCommand rval);
 267
 268                 public static bool TryToFcntlCommand (Int32 value, out FcntlCommand rval)
 269                 {
 270                         return ToFcntlCommand (value, out rval) == 0;
 271                 }
 272
 273                 public static FcntlCommand ToFcntlCommand (Int32 value)
 274                 {
 275                         FcntlCommand rval;
 276                         if (ToFcntlCommand (value, out rval) == -1)
 277                                 ThrowArgumentException (value);
 278                         return rval;
 279                 }
 280
 281                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFilePermissions")]
 282                 private static extern int FromFilePermissions (FilePermissions value, out UInt32 rval);
 283
 284                 public static bool TryFromFilePermissions (FilePermissions value, out UInt32 rval)
 285                 {
 286                         return FromFilePermissions (value, out rval) == 0;
 287                 }
 288
 289                 public static UInt32 FromFilePermissions (FilePermissions value)
 290                 {
 291                         UInt32 rval;
 292                         if (FromFilePermissions (value, out rval) == -1)
 293                                 ThrowArgumentException (value);
 294                         return rval;
 295                 }
 296
 297                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFilePermissions")]
 298                 private static extern int ToFilePermissions (UInt32 value, out FilePermissions rval);
 299
 300                 public static bool TryToFilePermissions (UInt32 value, out FilePermissions rval)
 301                 {
 302                         return ToFilePermissions (value, out rval) == 0;
 303                 }
 304
 305                 public static FilePermissions ToFilePermissions (UInt32 value)
 306                 {
 307                         FilePermissions rval;
 308                         if (ToFilePermissions (value, out rval) == -1)
 309                                 ThrowArgumentException (value);
 310                         return rval;
 311                 }
 312
 313                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFlock")]
 314                 private static extern int FromFlock (ref Flock source, IntPtr destination);
 315
 316                 public static bool TryCopy (ref Flock source, IntPtr destination)
 317                 {
 318                         return FromFlock (ref source, destination) == 0;
 319                 }
 320
 321                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFlock")]
 322                 private static extern int ToFlock (IntPtr source, out Flock destination);
 323
 324                 public static bool TryCopy (IntPtr source, out Flock destination)
 325                 {
 326                         return ToFlock (source, out destination) == 0;
 327                 }
 328
 329                 [DllImport (LIB, EntryPoint="Mono_Posix_FromIovec")]
 330                 private static extern int FromIovec (ref Iovec source, IntPtr destination);
 331
 332                 public static bool TryCopy (ref Iovec source, IntPtr destination)
 333                 {
 334                         return FromIovec (ref source, destination) == 0;
 335                 }
 336
 337                 [DllImport (LIB, EntryPoint="Mono_Posix_ToIovec")]
 338                 private static extern int ToIovec (IntPtr source, out Iovec destination);
 339
 340                 public static bool TryCopy (IntPtr source, out Iovec destination)
 341                 {
 342                         return ToIovec (source, out destination) == 0;
 343                 }
 344
 345                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLinger")]
 346                 private static extern int FromLinger (ref Linger source, IntPtr destination);
 347
 348                 public static bool TryCopy (ref Linger source, IntPtr destination)
 349                 {
 350                         return FromLinger (ref source, destination) == 0;
 351                 }
 352
 353                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLinger")]
 354                 private static extern int ToLinger (IntPtr source, out Linger destination);
 355
 356                 public static bool TryCopy (IntPtr source, out Linger destination)
 357                 {
 358                         return ToLinger (source, out destination) == 0;
 359                 }
 360
 361                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 362                 private static extern int FromLockType (LockType value, out Int16 rval);
 363
 364                 public static bool TryFromLockType (LockType value, out Int16 rval)
 365                 {
 366                         return FromLockType (value, out rval) == 0;
 367                 }
 368
 369                 public static Int16 FromLockType (LockType value)
 370                 {
 371                         Int16 rval;
 372                         if (FromLockType (value, out rval) == -1)
 373                                 ThrowArgumentException (value);
 374                         return rval;
 375                 }
 376
 377                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockType")]
 378                 private static extern int ToLockType (Int16 value, out LockType rval);
 379
 380                 public static bool TryToLockType (Int16 value, out LockType rval)
 381                 {
 382                         return ToLockType (value, out rval) == 0;
 383                 }
 384
 385                 public static LockType ToLockType (Int16 value)
 386                 {
 387                         LockType rval;
 388                         if (ToLockType (value, out rval) == -1)
 389                                 ThrowArgumentException (value);
 390                         return rval;
 391                 }
 392
 393                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockfCommand")]
 394                 private static extern int FromLockfCommand (LockfCommand value, out Int32 rval);
 395
 396                 public static bool TryFromLockfCommand (LockfCommand value, out Int32 rval)
 397                 {
 398                         return FromLockfCommand (value, out rval) == 0;
 399                 }
 400
 401                 public static Int32 FromLockfCommand (LockfCommand value)
 402                 {
 403                         Int32 rval;
 404                         if (FromLockfCommand (value, out rval) == -1)
 405                                 ThrowArgumentException (value);
 406                         return rval;
 407                 }
 408
 409                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockfCommand")]
 410                 private static extern int ToLockfCommand (Int32 value, out LockfCommand rval);
 411
 412                 public static bool TryToLockfCommand (Int32 value, out LockfCommand rval)
 413                 {
 414                         return ToLockfCommand (value, out rval) == 0;
 415                 }
 416
 417                 public static LockfCommand ToLockfCommand (Int32 value)
 418                 {
 419                         LockfCommand rval;
 420                         if (ToLockfCommand (value, out rval) == -1)
 421                                 ThrowArgumentException (value);
 422                         return rval;
 423                 }
 424
 425                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMessageFlags")]
 426                 private static extern int FromMessageFlags (MessageFlags value, out Int32 rval);
 427
 428                 public static bool TryFromMessageFlags (MessageFlags value, out Int32 rval)
 429                 {
 430                         return FromMessageFlags (value, out rval) == 0;
 431                 }
 432
 433                 public static Int32 FromMessageFlags (MessageFlags value)
 434                 {
 435                         Int32 rval;
 436                         if (FromMessageFlags (value, out rval) == -1)
 437                                 ThrowArgumentException (value);
 438                         return rval;
 439                 }
 440
 441                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMessageFlags")]
 442                 private static extern int ToMessageFlags (Int32 value, out MessageFlags rval);
 443
 444                 public static bool TryToMessageFlags (Int32 value, out MessageFlags rval)
 445                 {
 446                         return ToMessageFlags (value, out rval) == 0;
 447                 }
 448
 449                 public static MessageFlags ToMessageFlags (Int32 value)
 450                 {
 451                         MessageFlags rval;
 452                         if (ToMessageFlags (value, out rval) == -1)
 453                                 ThrowArgumentException (value);
 454                         return rval;
 455                 }
 456
 457                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMlockallFlags")]
 458                 private static extern int FromMlockallFlags (MlockallFlags value, out Int32 rval);
 459
 460                 public static bool TryFromMlockallFlags (MlockallFlags value, out Int32 rval)
 461                 {
 462                         return FromMlockallFlags (value, out rval) == 0;
 463                 }
 464
 465                 public static Int32 FromMlockallFlags (MlockallFlags value)
 466                 {
 467                         Int32 rval;
 468                         if (FromMlockallFlags (value, out rval) == -1)
 469                                 ThrowArgumentException (value);
 470                         return rval;
 471                 }
 472
 473                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMlockallFlags")]
 474                 private static extern int ToMlockallFlags (Int32 value, out MlockallFlags rval);
 475
 476                 public static bool TryToMlockallFlags (Int32 value, out MlockallFlags rval)
 477                 {
 478                         return ToMlockallFlags (value, out rval) == 0;
 479                 }
 480
 481                 public static MlockallFlags ToMlockallFlags (Int32 value)
 482                 {
 483                         MlockallFlags rval;
 484                         if (ToMlockallFlags (value, out rval) == -1)
 485                                 ThrowArgumentException (value);
 486                         return rval;
 487                 }
 488
 489                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapFlags")]
 490                 private static extern int FromMmapFlags (MmapFlags value, out Int32 rval);
 491
 492                 public static bool TryFromMmapFlags (MmapFlags value, out Int32 rval)
 493                 {
 494                         return FromMmapFlags (value, out rval) == 0;
 495                 }
 496
 497                 public static Int32 FromMmapFlags (MmapFlags value)
 498                 {
 499                         Int32 rval;
 500                         if (FromMmapFlags (value, out rval) == -1)
 501                                 ThrowArgumentException (value);
 502                         return rval;
 503                 }
 504
 505                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapFlags")]
 506                 private static extern int ToMmapFlags (Int32 value, out MmapFlags rval);
 507
 508                 public static bool TryToMmapFlags (Int32 value, out MmapFlags rval)
 509                 {
 510                         return ToMmapFlags (value, out rval) == 0;
 511                 }
 512
 513                 public static MmapFlags ToMmapFlags (Int32 value)
 514                 {
 515                         MmapFlags rval;
 516                         if (ToMmapFlags (value, out rval) == -1)
 517                                 ThrowArgumentException (value);
 518                         return rval;
 519                 }
 520
 521                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapProts")]
 522                 private static extern int FromMmapProts (MmapProts value, out Int32 rval);
 523
 524                 public static bool TryFromMmapProts (MmapProts value, out Int32 rval)
 525                 {
 526                         return FromMmapProts (value, out rval) == 0;
 527                 }
 528
 529                 public static Int32 FromMmapProts (MmapProts value)
 530                 {
 531                         Int32 rval;
 532                         if (FromMmapProts (value, out rval) == -1)
 533                                 ThrowArgumentException (value);
 534                         return rval;
 535                 }
 536
 537                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapProts")]
 538                 private static extern int ToMmapProts (Int32 value, out MmapProts rval);
 539
 540                 public static bool TryToMmapProts (Int32 value, out MmapProts rval)
 541                 {
 542                         return ToMmapProts (value, out rval) == 0;
 543                 }
 544
 545                 public static MmapProts ToMmapProts (Int32 value)
 546                 {
 547                         MmapProts rval;
 548                         if (ToMmapProts (value, out rval) == -1)
 549                                 ThrowArgumentException (value);
 550                         return rval;
 551                 }
 552
 553                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMountFlags")]
 554                 private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
 555
 556                 public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
 557                 {
 558                         return FromMountFlags (value, out rval) == 0;
 559                 }
 560
 561                 public static UInt64 FromMountFlags (MountFlags value)
 562                 {
 563                         UInt64 rval;
 564                         if (FromMountFlags (value, out rval) == -1)
 565                                 ThrowArgumentException (value);
 566                         return rval;
 567                 }
 568
 569                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMountFlags")]
 570                 private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
 571
 572                 public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
 573                 {
 574                         return ToMountFlags (value, out rval) == 0;
 575                 }
 576
 577                 public static MountFlags ToMountFlags (UInt64 value)
 578                 {
 579                         MountFlags rval;
 580                         if (ToMountFlags (value, out rval) == -1)
 581                                 ThrowArgumentException (value);
 582                         return rval;
 583                 }
 584
 585                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMremapFlags")]
 586                 private static extern int FromMremapFlags (MremapFlags value, out UInt64 rval);
 587
 588                 public static bool TryFromMremapFlags (MremapFlags value, out UInt64 rval)
 589                 {
 590                         return FromMremapFlags (value, out rval) == 0;
 591                 }
 592
 593                 public static UInt64 FromMremapFlags (MremapFlags value)
 594                 {
 595                         UInt64 rval;
 596                         if (FromMremapFlags (value, out rval) == -1)
 597                                 ThrowArgumentException (value);
 598                         return rval;
 599                 }
 600
 601                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMremapFlags")]
 602                 private static extern int ToMremapFlags (UInt64 value, out MremapFlags rval);
 603
 604                 public static bool TryToMremapFlags (UInt64 value, out MremapFlags rval)
 605                 {
 606                         return ToMremapFlags (value, out rval) == 0;
 607                 }
 608
 609                 public static MremapFlags ToMremapFlags (UInt64 value)
 610                 {
 611                         MremapFlags rval;
 612                         if (ToMremapFlags (value, out rval) == -1)
 613                                 ThrowArgumentException (value);
 614                         return rval;
 615                 }
 616
 617                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMsyncFlags")]
 618                 private static extern int FromMsyncFlags (MsyncFlags value, out Int32 rval);
 619
 620                 public static bool TryFromMsyncFlags (MsyncFlags value, out Int32 rval)
 621                 {
 622                         return FromMsyncFlags (value, out rval) == 0;
 623                 }
 624
 625                 public static Int32 FromMsyncFlags (MsyncFlags value)
 626                 {
 627                         Int32 rval;
 628                         if (FromMsyncFlags (value, out rval) == -1)
 629                                 ThrowArgumentException (value);
 630                         return rval;
 631                 }
 632
 633                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMsyncFlags")]
 634                 private static extern int ToMsyncFlags (Int32 value, out MsyncFlags rval);
 635
 636                 public static bool TryToMsyncFlags (Int32 value, out MsyncFlags rval)
 637                 {
 638                         return ToMsyncFlags (value, out rval) == 0;
 639                 }
 640
 641                 public static MsyncFlags ToMsyncFlags (Int32 value)
 642                 {
 643                         MsyncFlags rval;
 644                         if (ToMsyncFlags (value, out rval) == -1)
 645                                 ThrowArgumentException (value);
 646                         return rval;
 647                 }
 648
 649                 [DllImport (LIB, EntryPoint="Mono_Posix_FromOpenFlags")]
 650                 private static extern int FromOpenFlags (OpenFlags value, out Int32 rval);
 651
 652                 public static bool TryFromOpenFlags (OpenFlags value, out Int32 rval)
 653                 {
 654                         return FromOpenFlags (value, out rval) == 0;
 655                 }
 656
 657                 public static Int32 FromOpenFlags (OpenFlags value)
 658                 {
 659                         Int32 rval;
 660                         if (FromOpenFlags (value, out rval) == -1)
 661                                 ThrowArgumentException (value);
 662                         return rval;
 663                 }
 664
 665                 [DllImport (LIB, EntryPoint="Mono_Posix_ToOpenFlags")]
 666                 private static extern int ToOpenFlags (Int32 value, out OpenFlags rval);
 667
 668                 public static bool TryToOpenFlags (Int32 value, out OpenFlags rval)
 669                 {
 670                         return ToOpenFlags (value, out rval) == 0;
 671                 }
 672
 673                 public static OpenFlags ToOpenFlags (Int32 value)
 674                 {
 675                         OpenFlags rval;
 676                         if (ToOpenFlags (value, out rval) == -1)
 677                                 ThrowArgumentException (value);
 678                         return rval;
 679                 }
 680
 681                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathconfName")]
 682                 private static extern int FromPathconfName (PathconfName value, out Int32 rval);
 683
 684                 public static bool TryFromPathconfName (PathconfName value, out Int32 rval)
 685                 {
 686                         return FromPathconfName (value, out rval) == 0;
 687                 }
 688
 689                 public static Int32 FromPathconfName (PathconfName value)
 690                 {
 691                         Int32 rval;
 692                         if (FromPathconfName (value, out rval) == -1)
 693                                 ThrowArgumentException (value);
 694                         return rval;
 695                 }
 696
 697                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathconfName")]
 698                 private static extern int ToPathconfName (Int32 value, out PathconfName rval);
 699
 700                 public static bool TryToPathconfName (Int32 value, out PathconfName rval)
 701                 {
 702                         return ToPathconfName (value, out rval) == 0;
 703                 }
 704
 705                 public static PathconfName ToPathconfName (Int32 value)
 706                 {
 707                         PathconfName rval;
 708                         if (ToPathconfName (value, out rval) == -1)
 709                                 ThrowArgumentException (value);
 710                         return rval;
 711                 }
 712
 713                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollEvents")]
 714                 private static extern int FromPollEvents (PollEvents value, out Int16 rval);
 715
 716                 public static bool TryFromPollEvents (PollEvents value, out Int16 rval)
 717                 {
 718                         return FromPollEvents (value, out rval) == 0;
 719                 }
 720
 721                 public static Int16 FromPollEvents (PollEvents value)
 722                 {
 723                         Int16 rval;
 724                         if (FromPollEvents (value, out rval) == -1)
 725                                 ThrowArgumentException (value);
 726                         return rval;
 727                 }
 728
 729                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollEvents")]
 730                 private static extern int ToPollEvents (Int16 value, out PollEvents rval);
 731
 732                 public static bool TryToPollEvents (Int16 value, out PollEvents rval)
 733                 {
 734                         return ToPollEvents (value, out rval) == 0;
 735                 }
 736
 737                 public static PollEvents ToPollEvents (Int16 value)
 738                 {
 739                         PollEvents rval;
 740                         if (ToPollEvents (value, out rval) == -1)
 741                                 ThrowArgumentException (value);
 742                         return rval;
 743                 }
 744
 745                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollfd")]
 746                 private static extern int FromPollfd (ref Pollfd source, IntPtr destination);
 747
 748                 public static bool TryCopy (ref Pollfd source, IntPtr destination)
 749                 {
 750                         return FromPollfd (ref source, destination) == 0;
 751                 }
 752
 753                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollfd")]
 754                 private static extern int ToPollfd (IntPtr source, out Pollfd destination);
 755
 756                 public static bool TryCopy (IntPtr source, out Pollfd destination)
 757                 {
 758                         return ToPollfd (source, out destination) == 0;
 759                 }
 760
 761                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixFadviseAdvice")]
 762                 private static extern int FromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval);
 763
 764                 public static bool TryFromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval)
 765                 {
 766                         return FromPosixFadviseAdvice (value, out rval) == 0;
 767                 }
 768
 769                 public static Int32 FromPosixFadviseAdvice (PosixFadviseAdvice value)
 770                 {
 771                         Int32 rval;
 772                         if (FromPosixFadviseAdvice (value, out rval) == -1)
 773                                 ThrowArgumentException (value);
 774                         return rval;
 775                 }
 776
 777                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixFadviseAdvice")]
 778                 private static extern int ToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval);
 779
 780                 public static bool TryToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval)
 781                 {
 782                         return ToPosixFadviseAdvice (value, out rval) == 0;
 783                 }
 784
 785                 public static PosixFadviseAdvice ToPosixFadviseAdvice (Int32 value)
 786                 {
 787                         PosixFadviseAdvice rval;
 788                         if (ToPosixFadviseAdvice (value, out rval) == -1)
 789                                 ThrowArgumentException (value);
 790                         return rval;
 791                 }
 792
 793                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixMadviseAdvice")]
 794                 private static extern int FromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval);
 795
 796                 public static bool TryFromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval)
 797                 {
 798                         return FromPosixMadviseAdvice (value, out rval) == 0;
 799                 }
 800
 801                 public static Int32 FromPosixMadviseAdvice (PosixMadviseAdvice value)
 802                 {
 803                         Int32 rval;
 804                         if (FromPosixMadviseAdvice (value, out rval) == -1)
 805                                 ThrowArgumentException (value);
 806                         return rval;
 807                 }
 808
 809                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixMadviseAdvice")]
 810                 private static extern int ToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval);
 811
 812                 public static bool TryToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval)
 813                 {
 814                         return ToPosixMadviseAdvice (value, out rval) == 0;
 815                 }
 816
 817                 public static PosixMadviseAdvice ToPosixMadviseAdvice (Int32 value)
 818                 {
 819                         PosixMadviseAdvice rval;
 820                         if (ToPosixMadviseAdvice (value, out rval) == -1)
 821                                 ThrowArgumentException (value);
 822                         return rval;
 823                 }
 824
 825                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSeekFlags")]
 826                 private static extern int FromSeekFlags (SeekFlags value, out Int16 rval);
 827
 828                 public static bool TryFromSeekFlags (SeekFlags value, out Int16 rval)
 829                 {
 830                         return FromSeekFlags (value, out rval) == 0;
 831                 }
 832
 833                 public static Int16 FromSeekFlags (SeekFlags value)
 834                 {
 835                         Int16 rval;
 836                         if (FromSeekFlags (value, out rval) == -1)
 837                                 ThrowArgumentException (value);
 838                         return rval;
 839                 }
 840
 841                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSeekFlags")]
 842                 private static extern int ToSeekFlags (Int16 value, out SeekFlags rval);
 843
 844                 public static bool TryToSeekFlags (Int16 value, out SeekFlags rval)
 845                 {
 846                         return ToSeekFlags (value, out rval) == 0;
 847                 }
 848
 849                 public static SeekFlags ToSeekFlags (Int16 value)
 850                 {
 851                         SeekFlags rval;
 852                         if (ToSeekFlags (value, out rval) == -1)
 853                                 ThrowArgumentException (value);
 854                         return rval;
 855                 }
 856
 857                 [DllImport (LIB, EntryPoint="Mono_Posix_FromShutdownOption")]
 858                 private static extern int FromShutdownOption (ShutdownOption value, out Int32 rval);
 859
 860                 public static bool TryFromShutdownOption (ShutdownOption value, out Int32 rval)
 861                 {
 862                         return FromShutdownOption (value, out rval) == 0;
 863                 }
 864
 865                 public static Int32 FromShutdownOption (ShutdownOption value)
 866                 {
 867                         Int32 rval;
 868                         if (FromShutdownOption (value, out rval) == -1)
 869                                 ThrowArgumentException (value);
 870                         return rval;
 871                 }
 872
 873                 [DllImport (LIB, EntryPoint="Mono_Posix_ToShutdownOption")]
 874                 private static extern int ToShutdownOption (Int32 value, out ShutdownOption rval);
 875
 876                 public static bool TryToShutdownOption (Int32 value, out ShutdownOption rval)
 877                 {
 878                         return ToShutdownOption (value, out rval) == 0;
 879                 }
 880
 881                 public static ShutdownOption ToShutdownOption (Int32 value)
 882                 {
 883                         ShutdownOption rval;
 884                         if (ToShutdownOption (value, out rval) == -1)
 885                                 ThrowArgumentException (value);
 886                         return rval;
 887                 }
 888
 889                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSignum")]
 890                 private static extern int FromSignum (Signum value, out Int32 rval);
 891
 892                 public static bool TryFromSignum (Signum value, out Int32 rval)
 893                 {
 894                         return FromSignum (value, out rval) == 0;
 895                 }
 896
 897                 public static Int32 FromSignum (Signum value)
 898                 {
 899                         Int32 rval;
 900                         if (FromSignum (value, out rval) == -1)
 901                                 ThrowArgumentException (value);
 902                         return rval;
 903                 }
 904
 905                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSignum")]
 906                 private static extern int ToSignum (Int32 value, out Signum rval);
 907
 908                 public static bool TryToSignum (Int32 value, out Signum rval)
 909                 {
 910                         return ToSignum (value, out rval) == 0;
 911                 }
 912
 913                 public static Signum ToSignum (Int32 value)
 914                 {
 915                         Signum rval;
 916                         if (ToSignum (value, out rval) == -1)
 917                                 ThrowArgumentException (value);
 918                         return rval;
 919                 }
 920
 921                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysconfName")]
 922                 private static extern int FromSysconfName (SysconfName value, out Int32 rval);
 923
 924                 public static bool TryFromSysconfName (SysconfName value, out Int32 rval)
 925                 {
 926                         return FromSysconfName (value, out rval) == 0;
 927                 }
 928
 929                 public static Int32 FromSysconfName (SysconfName value)
 930                 {
 931                         Int32 rval;
 932                         if (FromSysconfName (value, out rval) == -1)
 933                                 ThrowArgumentException (value);
 934                         return rval;
 935                 }
 936
 937                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysconfName")]
 938                 private static extern int ToSysconfName (Int32 value, out SysconfName rval);
 939
 940                 public static bool TryToSysconfName (Int32 value, out SysconfName rval)
 941                 {
 942                         return ToSysconfName (value, out rval) == 0;
 943                 }
 944
 945                 public static SysconfName ToSysconfName (Int32 value)
 946                 {
 947                         SysconfName rval;
 948                         if (ToSysconfName (value, out rval) == -1)
 949                                 ThrowArgumentException (value);
 950                         return rval;
 951                 }
 952
 953                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogFacility")]
 954                 private static extern int FromSyslogFacility (SyslogFacility value, out Int32 rval);
 955
 956                 public static bool TryFromSyslogFacility (SyslogFacility value, out Int32 rval)
 957                 {
 958                         return FromSyslogFacility (value, out rval) == 0;
 959                 }
 960
 961                 public static Int32 FromSyslogFacility (SyslogFacility value)
 962                 {
 963                         Int32 rval;
 964                         if (FromSyslogFacility (value, out rval) == -1)
 965                                 ThrowArgumentException (value);
 966                         return rval;
 967                 }
 968
 969                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogFacility")]
 970                 private static extern int ToSyslogFacility (Int32 value, out SyslogFacility rval);
 971
 972                 public static bool TryToSyslogFacility (Int32 value, out SyslogFacility rval)
 973                 {
 974                         return ToSyslogFacility (value, out rval) == 0;
 975                 }
 976
 977                 public static SyslogFacility ToSyslogFacility (Int32 value)
 978                 {
 979                         SyslogFacility rval;
 980                         if (ToSyslogFacility (value, out rval) == -1)
 981                                 ThrowArgumentException (value);
 982                         return rval;
 983                 }
 984
 985                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogLevel")]
 986                 private static extern int FromSyslogLevel (SyslogLevel value, out Int32 rval);
 987
 988                 public static bool TryFromSyslogLevel (SyslogLevel value, out Int32 rval)
 989                 {
 990                         return FromSyslogLevel (value, out rval) == 0;
 991                 }
 992
 993                 public static Int32 FromSyslogLevel (SyslogLevel value)
 994                 {
 995                         Int32 rval;
 996                         if (FromSyslogLevel (value, out rval) == -1)
 997                                 ThrowArgumentException (value);
 998                         return rval;
 999                 }
1000
1001                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogLevel")]
1002                 private static extern int ToSyslogLevel (Int32 value, out SyslogLevel rval);
1003
1004                 public static bool TryToSyslogLevel (Int32 value, out SyslogLevel rval)
1005                 {
1006                         return ToSyslogLevel (value, out rval) == 0;
1007                 }
1008
1009                 public static SyslogLevel ToSyslogLevel (Int32 value)
1010                 {
1011                         SyslogLevel rval;
1012                         if (ToSyslogLevel (value, out rval) == -1)
1013                                 ThrowArgumentException (value);
1014                         return rval;
1015                 }
1016
1017                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogOptions")]
1018                 private static extern int FromSyslogOptions (SyslogOptions value, out Int32 rval);
1019
1020                 public static bool TryFromSyslogOptions (SyslogOptions value, out Int32 rval)
1021                 {
1022                         return FromSyslogOptions (value, out rval) == 0;
1023                 }
1024
1025                 public static Int32 FromSyslogOptions (SyslogOptions value)
1026                 {
1027                         Int32 rval;
1028                         if (FromSyslogOptions (value, out rval) == -1)
1029                                 ThrowArgumentException (value);
1030                         return rval;
1031                 }
1032
1033                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogOptions")]
1034                 private static extern int ToSyslogOptions (Int32 value, out SyslogOptions rval);
1035
1036                 public static bool TryToSyslogOptions (Int32 value, out SyslogOptions rval)
1037                 {
1038                         return ToSyslogOptions (value, out rval) == 0;
1039                 }
1040
1041                 public static SyslogOptions ToSyslogOptions (Int32 value)
1042                 {
1043                         SyslogOptions rval;
1044                         if (ToSyslogOptions (value, out rval) == -1)
1045                                 ThrowArgumentException (value);
1046                         return rval;
1047                 }
1048
1049                 [DllImport (LIB, EntryPoint="Mono_Posix_FromTimespec")]
1050                 private static extern int FromTimespec (ref Timespec source, IntPtr destination);
1051
1052                 public static bool TryCopy (ref Timespec source, IntPtr destination)
1053                 {
1054                         return FromTimespec (ref source, destination) == 0;
1055                 }
1056
1057                 [DllImport (LIB, EntryPoint="Mono_Posix_ToTimespec")]
1058                 private static extern int ToTimespec (IntPtr source, out Timespec destination);
1059
1060                 public static bool TryCopy (IntPtr source, out Timespec destination)
1061                 {
1062                         return ToTimespec (source, out destination) == 0;
1063                 }
1064
1065                 [DllImport (LIB, EntryPoint="Mono_Posix_FromTimeval")]
1066                 private static extern int FromTimeval (ref Timeval source, IntPtr destination);
1067
1068                 public static bool TryCopy (ref Timeval source, IntPtr destination)
1069                 {
1070                         return FromTimeval (ref source, destination) == 0;
1071                 }
1072
1073                 [DllImport (LIB, EntryPoint="Mono_Posix_ToTimeval")]
1074                 private static extern int ToTimeval (IntPtr source, out Timeval destination);
1075
1076                 public static bool TryCopy (IntPtr source, out Timeval destination)
1077                 {
1078                         return ToTimeval (source, out destination) == 0;
1079                 }
1080
1081                 [DllImport (LIB, EntryPoint="Mono_Posix_FromTimezone")]
1082                 private static extern int FromTimezone (ref Timezone source, IntPtr destination);
1083
1084                 public static bool TryCopy (ref Timezone source, IntPtr destination)
1085                 {
1086                         return FromTimezone (ref source, destination) == 0;
1087                 }
1088
1089                 [DllImport (LIB, EntryPoint="Mono_Posix_ToTimezone")]
1090                 private static extern int ToTimezone (IntPtr source, out Timezone destination);
1091
1092                 public static bool TryCopy (IntPtr source, out Timezone destination)
1093                 {
1094                         return ToTimezone (source, out destination) == 0;
1095                 }
1096
1097                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUnixAddressFamily")]
1098                 private static extern int FromUnixAddressFamily (UnixAddressFamily value, out Int32 rval);
1099
1100                 public static bool TryFromUnixAddressFamily (UnixAddressFamily value, out Int32 rval)
1101                 {
1102                         return FromUnixAddressFamily (value, out rval) == 0;
1103                 }
1104
1105                 public static Int32 FromUnixAddressFamily (UnixAddressFamily value)
1106                 {
1107                         Int32 rval;
1108                         if (FromUnixAddressFamily (value, out rval) == -1)
1109                                 ThrowArgumentException (value);
1110                         return rval;
1111                 }
1112
1113                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUnixAddressFamily")]
1114                 private static extern int ToUnixAddressFamily (Int32 value, out UnixAddressFamily rval);
1115
1116                 public static bool TryToUnixAddressFamily (Int32 value, out UnixAddressFamily rval)
1117                 {
1118                         return ToUnixAddressFamily (value, out rval) == 0;
1119                 }
1120
1121                 public static UnixAddressFamily ToUnixAddressFamily (Int32 value)
1122                 {
1123                         UnixAddressFamily rval;
1124                         if (ToUnixAddressFamily (value, out rval) == -1)
1125                                 ThrowArgumentException (value);
1126                         return rval;
1127                 }
1128
1129                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUnixSocketFlags")]
1130                 private static extern int FromUnixSocketFlags (UnixSocketFlags value, out Int32 rval);
1131
1132                 public static bool TryFromUnixSocketFlags (UnixSocketFlags value, out Int32 rval)
1133                 {
1134                         return FromUnixSocketFlags (value, out rval) == 0;
1135                 }
1136
1137                 public static Int32 FromUnixSocketFlags (UnixSocketFlags value)
1138                 {
1139                         Int32 rval;
1140                         if (FromUnixSocketFlags (value, out rval) == -1)
1141                                 ThrowArgumentException (value);
1142                         return rval;
1143                 }
1144
1145                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUnixSocketFlags")]
1146                 private static extern int ToUnixSocketFlags (Int32 value, out UnixSocketFlags rval);
1147
1148                 public static bool TryToUnixSocketFlags (Int32 value, out UnixSocketFlags rval)
1149                 {
1150                         return ToUnixSocketFlags (value, out rval) == 0;
1151                 }
1152
1153                 public static UnixSocketFlags ToUnixSocketFlags (Int32 value)
1154                 {
1155                         UnixSocketFlags rval;
1156                         if (ToUnixSocketFlags (value, out rval) == -1)
1157                                 ThrowArgumentException (value);
1158                         return rval;
1159                 }
1160
1161                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUnixSocketOptionName")]
1162                 private static extern int FromUnixSocketOptionName (UnixSocketOptionName value, out Int32 rval);
1163
1164                 public static bool TryFromUnixSocketOptionName (UnixSocketOptionName value, out Int32 rval)
1165                 {
1166                         return FromUnixSocketOptionName (value, out rval) == 0;
1167                 }
1168
1169                 public static Int32 FromUnixSocketOptionName (UnixSocketOptionName value)
1170                 {
1171                         Int32 rval;
1172                         if (FromUnixSocketOptionName (value, out rval) == -1)
1173                                 ThrowArgumentException (value);
1174                         return rval;
1175                 }
1176
1177                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUnixSocketOptionName")]
1178                 private static extern int ToUnixSocketOptionName (Int32 value, out UnixSocketOptionName rval);
1179
1180                 public static bool TryToUnixSocketOptionName (Int32 value, out UnixSocketOptionName rval)
1181                 {
1182                         return ToUnixSocketOptionName (value, out rval) == 0;
1183                 }
1184
1185                 public static UnixSocketOptionName ToUnixSocketOptionName (Int32 value)
1186                 {
1187                         UnixSocketOptionName rval;
1188                         if (ToUnixSocketOptionName (value, out rval) == -1)
1189                                 ThrowArgumentException (value);
1190                         return rval;
1191                 }
1192
1193                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUnixSocketProtocol")]
1194                 private static extern int FromUnixSocketProtocol (UnixSocketProtocol value, out Int32 rval);
1195
1196                 public static bool TryFromUnixSocketProtocol (UnixSocketProtocol value, out Int32 rval)
1197                 {
1198                         return FromUnixSocketProtocol (value, out rval) == 0;
1199                 }
1200
1201                 public static Int32 FromUnixSocketProtocol (UnixSocketProtocol value)
1202                 {
1203                         Int32 rval;
1204                         if (FromUnixSocketProtocol (value, out rval) == -1)
1205                                 ThrowArgumentException (value);
1206                         return rval;
1207                 }
1208
1209                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUnixSocketProtocol")]
1210                 private static extern int ToUnixSocketProtocol (Int32 value, out UnixSocketProtocol rval);
1211
1212                 public static bool TryToUnixSocketProtocol (Int32 value, out UnixSocketProtocol rval)
1213                 {
1214                         return ToUnixSocketProtocol (value, out rval) == 0;
1215                 }
1216
1217                 public static UnixSocketProtocol ToUnixSocketProtocol (Int32 value)
1218                 {
1219                         UnixSocketProtocol rval;
1220                         if (ToUnixSocketProtocol (value, out rval) == -1)
1221                                 ThrowArgumentException (value);
1222                         return rval;
1223                 }
1224
1225                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUnixSocketType")]
1226                 private static extern int FromUnixSocketType (UnixSocketType value, out Int32 rval);
1227
1228                 public static bool TryFromUnixSocketType (UnixSocketType value, out Int32 rval)
1229                 {
1230                         return FromUnixSocketType (value, out rval) == 0;
1231                 }
1232
1233                 public static Int32 FromUnixSocketType (UnixSocketType value)
1234                 {
1235                         Int32 rval;
1236                         if (FromUnixSocketType (value, out rval) == -1)
1237                                 ThrowArgumentException (value);
1238                         return rval;
1239                 }
1240
1241                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUnixSocketType")]
1242                 private static extern int ToUnixSocketType (Int32 value, out UnixSocketType rval);
1243
1244                 public static bool TryToUnixSocketType (Int32 value, out UnixSocketType rval)
1245                 {
1246                         return ToUnixSocketType (value, out rval) == 0;
1247                 }
1248
1249                 public static UnixSocketType ToUnixSocketType (Int32 value)
1250                 {
1251                         UnixSocketType rval;
1252                         if (ToUnixSocketType (value, out rval) == -1)
1253                                 ThrowArgumentException (value);
1254                         return rval;
1255                 }
1256
1257                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUtimbuf")]
1258                 private static extern int FromUtimbuf (ref Utimbuf source, IntPtr destination);
1259
1260                 public static bool TryCopy (ref Utimbuf source, IntPtr destination)
1261                 {
1262                         return FromUtimbuf (ref source, destination) == 0;
1263                 }
1264
1265                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUtimbuf")]
1266                 private static extern int ToUtimbuf (IntPtr source, out Utimbuf destination);
1267
1268                 public static bool TryCopy (IntPtr source, out Utimbuf destination)
1269                 {
1270                         return ToUtimbuf (source, out destination) == 0;
1271                 }
1272
1273                 [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
1274                 private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);
1275
1276                 public static bool TryFromWaitOptions (WaitOptions value, out Int32 rval)
1277                 {
1278                         return FromWaitOptions (value, out rval) == 0;
1279                 }
1280
1281                 public static Int32 FromWaitOptions (WaitOptions value)
1282                 {
1283                         Int32 rval;
1284                         if (FromWaitOptions (value, out rval) == -1)
1285                                 ThrowArgumentException (value);
1286                         return rval;
1287                 }
1288
1289                 [DllImport (LIB, EntryPoint="Mono_Posix_ToWaitOptions")]
1290                 private static extern int ToWaitOptions (Int32 value, out WaitOptions rval);
1291
1292                 public static bool TryToWaitOptions (Int32 value, out WaitOptions rval)
1293                 {
1294                         return ToWaitOptions (value, out rval) == 0;
1295                 }
1296
1297                 public static WaitOptions ToWaitOptions (Int32 value)
1298                 {
1299                         WaitOptions rval;
1300                         if (ToWaitOptions (value, out rval) == -1)
1301                                 ThrowArgumentException (value);
1302                         return rval;
1303                 }
1304
1305                 [DllImport (LIB, EntryPoint="Mono_Posix_FromXattrFlags")]
1306                 private static extern int FromXattrFlags (XattrFlags value, out Int32 rval);
1307
1308                 public static bool TryFromXattrFlags (XattrFlags value, out Int32 rval)
1309                 {
1310                         return FromXattrFlags (value, out rval) == 0;
1311                 }
1312
1313                 public static Int32 FromXattrFlags (XattrFlags value)
1314                 {
1315                         Int32 rval;
1316                         if (FromXattrFlags (value, out rval) == -1)
1317                                 ThrowArgumentException (value);
1318                         return rval;
1319                 }
1320
1321                 [DllImport (LIB, EntryPoint="Mono_Posix_ToXattrFlags")]
1322                 private static extern int ToXattrFlags (Int32 value, out XattrFlags rval);
1323
1324                 public static bool TryToXattrFlags (Int32 value, out XattrFlags rval)
1325                 {
1326                         return ToXattrFlags (value, out rval) == 0;
1327                 }
1328
1329                 public static XattrFlags ToXattrFlags (Int32 value)
1330                 {
1331                         XattrFlags rval;
1332                         if (ToXattrFlags (value, out rval) == -1)
1333                                 ThrowArgumentException (value);
1334                         return rval;
1335                 }
1336
1337         }
1338 }
1339