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

   1 /*
   2  * This file was automatically generated by make-map from 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         [CLSCompliant (false)]
  14         public sealed /* static */ partial class NativeConvert
  15         {
  16                 private NativeConvert () {}
  17
  18                 private const string LIB = "MonoPosixHelper";
  19
  20                 private static void ThrowArgumentException (object value)
  21                 {
  22                         throw new ArgumentOutOfRangeException ("value", value,
  23                                 Locale.GetText ("Current platform doesn't support this value."));
  24                 }
  25
  26                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAccessMode")]
  27                 private static extern int FromAccessMode (AccessMode value, out Int32 rval);
  28
  29                 [Obsolete ("Use Mono.Unix.Native.AccessModes")]
  30                 public static bool TryFromAccessMode (AccessMode value, out Int32 rval)
  31                 {
  32                         return FromAccessMode (value, out rval) == 0;
  33                 }
  34
  35                 [Obsolete ("Use Mono.Unix.Native.AccessModes")]
  36                 public static Int32 FromAccessMode (AccessMode value)
  37                 {
  38                         Int32 rval;
  39                         if (FromAccessMode (value, out rval) == -1)
  40                                 ThrowArgumentException (value);
  41                         return rval;
  42                 }
  43
  44                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessMode")]
  45                 private static extern int ToAccessMode (Int32 value, out AccessMode rval);
  46
  47                 [Obsolete ("Use Mono.Unix.Native.AccessModes")]
  48                 public static bool TryToAccessMode (Int32 value, out AccessMode rval)
  49                 {
  50                         return ToAccessMode (value, out rval) == 0;
  51                 }
  52
  53                 [Obsolete ("Use Mono.Unix.Native.AccessModes")]
  54                 public static AccessMode ToAccessMode (Int32 value)
  55                 {
  56                         AccessMode rval;
  57                         if (ToAccessMode (value, out rval) == -1)
  58                                 ThrowArgumentException (value);
  59                         return rval;
  60                 }
  61
  62                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfStr")]
  63                 private static extern int FromConfStr (ConfStr value, out Int32 rval);
  64
  65                 [Obsolete ("Use Mono.Unix.Native.ConfstrName")]
  66                 public static bool TryFromConfStr (ConfStr value, out Int32 rval)
  67                 {
  68                         return FromConfStr (value, out rval) == 0;
  69                 }
  70
  71                 [Obsolete ("Use Mono.Unix.Native.ConfstrName")]
  72                 public static Int32 FromConfStr (ConfStr value)
  73                 {
  74                         Int32 rval;
  75                         if (FromConfStr (value, out rval) == -1)
  76                                 ThrowArgumentException (value);
  77                         return rval;
  78                 }
  79
  80                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfStr")]
  81                 private static extern int ToConfStr (Int32 value, out ConfStr rval);
  82
  83                 [Obsolete ("Use Mono.Unix.Native.ConfstrName")]
  84                 public static bool TryToConfStr (Int32 value, out ConfStr rval)
  85                 {
  86                         return ToConfStr (value, out rval) == 0;
  87                 }
  88
  89                 [Obsolete ("Use Mono.Unix.Native.ConfstrName")]
  90                 public static ConfStr ToConfStr (Int32 value)
  91                 {
  92                         ConfStr rval;
  93                         if (ToConfStr (value, out rval) == -1)
  94                                 ThrowArgumentException (value);
  95                         return rval;
  96                 }
  97
  98                 [DllImport (LIB, EntryPoint="Mono_Posix_FromError")]
  99                 private static extern int FromError (Error value, out Int32 rval);
 100
 101                 [Obsolete ("Use Mono.Unix.Native.Errno")]
 102                 public static bool TryFromError (Error value, out Int32 rval)
 103                 {
 104                         return FromError (value, out rval) == 0;
 105                 }
 106
 107                 [Obsolete ("Use Mono.Unix.Native.Errno")]
 108                 public static Int32 FromError (Error value)
 109                 {
 110                         Int32 rval;
 111                         if (FromError (value, out rval) == -1)
 112                                 ThrowArgumentException (value);
 113                         return rval;
 114                 }
 115
 116                 [DllImport (LIB, EntryPoint="Mono_Posix_ToError")]
 117                 private static extern int ToError (Int32 value, out Error rval);
 118
 119                 [Obsolete ("Use Mono.Unix.Native.Errno")]
 120                 public static bool TryToError (Int32 value, out Error rval)
 121                 {
 122                         return ToError (value, out rval) == 0;
 123                 }
 124
 125                 [Obsolete ("Use Mono.Unix.Native.Errno")]
 126                 public static Error ToError (Int32 value)
 127                 {
 128                         Error rval;
 129                         if (ToError (value, out rval) == -1)
 130                                 ThrowArgumentException (value);
 131                         return rval;
 132                 }
 133
 134                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapProt")]
 135                 private static extern int FromMmapProt (MmapProt value, out Int32 rval);
 136
 137                 [Obsolete ("Use Mono.Unix.Native.MmapProts")]
 138                 public static bool TryFromMmapProt (MmapProt value, out Int32 rval)
 139                 {
 140                         return FromMmapProt (value, out rval) == 0;
 141                 }
 142
 143                 [Obsolete ("Use Mono.Unix.Native.MmapProts")]
 144                 public static Int32 FromMmapProt (MmapProt value)
 145                 {
 146                         Int32 rval;
 147                         if (FromMmapProt (value, out rval) == -1)
 148                                 ThrowArgumentException (value);
 149                         return rval;
 150                 }
 151
 152                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapProt")]
 153                 private static extern int ToMmapProt (Int32 value, out MmapProt rval);
 154
 155                 [Obsolete ("Use Mono.Unix.Native.MmapProts")]
 156                 public static bool TryToMmapProt (Int32 value, out MmapProt rval)
 157                 {
 158                         return ToMmapProt (value, out rval) == 0;
 159                 }
 160
 161                 [Obsolete ("Use Mono.Unix.Native.MmapProts")]
 162                 public static MmapProt ToMmapProt (Int32 value)
 163                 {
 164                         MmapProt rval;
 165                         if (ToMmapProt (value, out rval) == -1)
 166                                 ThrowArgumentException (value);
 167                         return rval;
 168                 }
 169
 170                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAccessModes")]
 171                 private static extern int FromAccessModes (AccessModes value, out Int32 rval);
 172
 173                 public static bool TryFromAccessModes (AccessModes value, out Int32 rval)
 174                 {
 175                         return FromAccessModes (value, out rval) == 0;
 176                 }
 177
 178                 public static Int32 FromAccessModes (AccessModes value)
 179                 {
 180                         Int32 rval;
 181                         if (FromAccessModes (value, out rval) == -1)
 182                                 ThrowArgumentException (value);
 183                         return rval;
 184                 }
 185
 186                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessModes")]
 187                 private static extern int ToAccessModes (Int32 value, out AccessModes rval);
 188
 189                 public static bool TryToAccessModes (Int32 value, out AccessModes rval)
 190                 {
 191                         return ToAccessModes (value, out rval) == 0;
 192                 }
 193
 194                 public static AccessModes ToAccessModes (Int32 value)
 195                 {
 196                         AccessModes rval;
 197                         if (ToAccessModes (value, out rval) == -1)
 198                                 ThrowArgumentException (value);
 199                         return rval;
 200                 }
 201
 202                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfstrName")]
 203                 private static extern int FromConfstrName (ConfstrName value, out Int32 rval);
 204
 205                 public static bool TryFromConfstrName (ConfstrName value, out Int32 rval)
 206                 {
 207                         return FromConfstrName (value, out rval) == 0;
 208                 }
 209
 210                 public static Int32 FromConfstrName (ConfstrName value)
 211                 {
 212                         Int32 rval;
 213                         if (FromConfstrName (value, out rval) == -1)
 214                                 ThrowArgumentException (value);
 215                         return rval;
 216                 }
 217
 218                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfstrName")]
 219                 private static extern int ToConfstrName (Int32 value, out ConfstrName rval);
 220
 221                 public static bool TryToConfstrName (Int32 value, out ConfstrName rval)
 222                 {
 223                         return ToConfstrName (value, out rval) == 0;
 224                 }
 225
 226                 public static ConfstrName ToConfstrName (Int32 value)
 227                 {
 228                         ConfstrName rval;
 229                         if (ToConfstrName (value, out rval) == -1)
 230                                 ThrowArgumentException (value);
 231                         return rval;
 232                 }
 233
 234                 [DllImport (LIB, EntryPoint="Mono_Posix_FromDirectoryNotifyFlags")]
 235                 private static extern int FromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval);
 236
 237                 public static bool TryFromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval)
 238                 {
 239                         return FromDirectoryNotifyFlags (value, out rval) == 0;
 240                 }
 241
 242                 public static Int32 FromDirectoryNotifyFlags (DirectoryNotifyFlags value)
 243                 {
 244                         Int32 rval;
 245                         if (FromDirectoryNotifyFlags (value, out rval) == -1)
 246                                 ThrowArgumentException (value);
 247                         return rval;
 248                 }
 249
 250                 [DllImport (LIB, EntryPoint="Mono_Posix_ToDirectoryNotifyFlags")]
 251                 private static extern int ToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval);
 252
 253                 public static bool TryToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval)
 254                 {
 255                         return ToDirectoryNotifyFlags (value, out rval) == 0;
 256                 }
 257
 258                 public static DirectoryNotifyFlags ToDirectoryNotifyFlags (Int32 value)
 259                 {
 260                         DirectoryNotifyFlags rval;
 261                         if (ToDirectoryNotifyFlags (value, out rval) == -1)
 262                                 ThrowArgumentException (value);
 263                         return rval;
 264                 }
 265
 266                 [DllImport (LIB, EntryPoint="Mono_Posix_FromErrno")]
 267                 private static extern int FromErrno (Errno value, out Int32 rval);
 268
 269                 public static bool TryFromErrno (Errno value, out Int32 rval)
 270                 {
 271                         return FromErrno (value, out rval) == 0;
 272                 }
 273
 274                 public static Int32 FromErrno (Errno value)
 275                 {
 276                         Int32 rval;
 277                         if (FromErrno (value, out rval) == -1)
 278                                 ThrowArgumentException (value);
 279                         return rval;
 280                 }
 281
 282                 [DllImport (LIB, EntryPoint="Mono_Posix_ToErrno")]
 283                 private static extern int ToErrno (Int32 value, out Errno rval);
 284
 285                 public static bool TryToErrno (Int32 value, out Errno rval)
 286                 {
 287                         return ToErrno (value, out rval) == 0;
 288                 }
 289
 290                 public static Errno ToErrno (Int32 value)
 291                 {
 292                         Errno rval;
 293                         if (ToErrno (value, out rval) == -1)
 294                                 ThrowArgumentException (value);
 295                         return rval;
 296                 }
 297
 298                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFcntlCommand")]
 299                 private static extern int FromFcntlCommand (FcntlCommand value, out Int32 rval);
 300
 301                 public static bool TryFromFcntlCommand (FcntlCommand value, out Int32 rval)
 302                 {
 303                         return FromFcntlCommand (value, out rval) == 0;
 304                 }
 305
 306                 public static Int32 FromFcntlCommand (FcntlCommand value)
 307                 {
 308                         Int32 rval;
 309                         if (FromFcntlCommand (value, out rval) == -1)
 310                                 ThrowArgumentException (value);
 311                         return rval;
 312                 }
 313
 314                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFcntlCommand")]
 315                 private static extern int ToFcntlCommand (Int32 value, out FcntlCommand rval);
 316
 317                 public static bool TryToFcntlCommand (Int32 value, out FcntlCommand rval)
 318                 {
 319                         return ToFcntlCommand (value, out rval) == 0;
 320                 }
 321
 322                 public static FcntlCommand ToFcntlCommand (Int32 value)
 323                 {
 324                         FcntlCommand rval;
 325                         if (ToFcntlCommand (value, out rval) == -1)
 326                                 ThrowArgumentException (value);
 327                         return rval;
 328                 }
 329
 330                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFilePermissions")]
 331                 private static extern int FromFilePermissions (FilePermissions value, out UInt32 rval);
 332
 333                 public static bool TryFromFilePermissions (FilePermissions value, out UInt32 rval)
 334                 {
 335                         return FromFilePermissions (value, out rval) == 0;
 336                 }
 337
 338                 public static UInt32 FromFilePermissions (FilePermissions value)
 339                 {
 340                         UInt32 rval;
 341                         if (FromFilePermissions (value, out rval) == -1)
 342                                 ThrowArgumentException (value);
 343                         return rval;
 344                 }
 345
 346                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFilePermissions")]
 347                 private static extern int ToFilePermissions (UInt32 value, out FilePermissions rval);
 348
 349                 public static bool TryToFilePermissions (UInt32 value, out FilePermissions rval)
 350                 {
 351                         return ToFilePermissions (value, out rval) == 0;
 352                 }
 353
 354                 public static FilePermissions ToFilePermissions (UInt32 value)
 355                 {
 356                         FilePermissions rval;
 357                         if (ToFilePermissions (value, out rval) == -1)
 358                                 ThrowArgumentException (value);
 359                         return rval;
 360                 }
 361
 362                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 363                 private static extern int FromLockType (LockType value, out Int16 rval);
 364
 365                 public static bool TryFromLockType (LockType value, out Int16 rval)
 366                 {
 367                         return FromLockType (value, out rval) == 0;
 368                 }
 369
 370                 public static Int16 FromLockType (LockType value)
 371                 {
 372                         Int16 rval;
 373                         if (FromLockType (value, out rval) == -1)
 374                                 ThrowArgumentException (value);
 375                         return rval;
 376                 }
 377
 378                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockType")]
 379                 private static extern int ToLockType (Int16 value, out LockType rval);
 380
 381                 public static bool TryToLockType (Int16 value, out LockType rval)
 382                 {
 383                         return ToLockType (value, out rval) == 0;
 384                 }
 385
 386                 public static LockType ToLockType (Int16 value)
 387                 {
 388                         LockType rval;
 389                         if (ToLockType (value, out rval) == -1)
 390                                 ThrowArgumentException (value);
 391                         return rval;
 392                 }
 393
 394                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockfCommand")]
 395                 private static extern int FromLockfCommand (LockfCommand value, out Int32 rval);
 396
 397                 public static bool TryFromLockfCommand (LockfCommand value, out Int32 rval)
 398                 {
 399                         return FromLockfCommand (value, out rval) == 0;
 400                 }
 401
 402                 public static Int32 FromLockfCommand (LockfCommand value)
 403                 {
 404                         Int32 rval;
 405                         if (FromLockfCommand (value, out rval) == -1)
 406                                 ThrowArgumentException (value);
 407                         return rval;
 408                 }
 409
 410                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockfCommand")]
 411                 private static extern int ToLockfCommand (Int32 value, out LockfCommand rval);
 412
 413                 public static bool TryToLockfCommand (Int32 value, out LockfCommand rval)
 414                 {
 415                         return ToLockfCommand (value, out rval) == 0;
 416                 }
 417
 418                 public static LockfCommand ToLockfCommand (Int32 value)
 419                 {
 420                         LockfCommand rval;
 421                         if (ToLockfCommand (value, out rval) == -1)
 422                                 ThrowArgumentException (value);
 423                         return rval;
 424                 }
 425
 426                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMlockallFlags")]
 427                 private static extern int FromMlockallFlags (MlockallFlags value, out Int32 rval);
 428
 429                 public static bool TryFromMlockallFlags (MlockallFlags value, out Int32 rval)
 430                 {
 431                         return FromMlockallFlags (value, out rval) == 0;
 432                 }
 433
 434                 public static Int32 FromMlockallFlags (MlockallFlags value)
 435                 {
 436                         Int32 rval;
 437                         if (FromMlockallFlags (value, out rval) == -1)
 438                                 ThrowArgumentException (value);
 439                         return rval;
 440                 }
 441
 442                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMlockallFlags")]
 443                 private static extern int ToMlockallFlags (Int32 value, out MlockallFlags rval);
 444
 445                 public static bool TryToMlockallFlags (Int32 value, out MlockallFlags rval)
 446                 {
 447                         return ToMlockallFlags (value, out rval) == 0;
 448                 }
 449
 450                 public static MlockallFlags ToMlockallFlags (Int32 value)
 451                 {
 452                         MlockallFlags rval;
 453                         if (ToMlockallFlags (value, out rval) == -1)
 454                                 ThrowArgumentException (value);
 455                         return rval;
 456                 }
 457
 458                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapFlags")]
 459                 private static extern int FromMmapFlags (MmapFlags value, out Int32 rval);
 460
 461                 public static bool TryFromMmapFlags (MmapFlags value, out Int32 rval)
 462                 {
 463                         return FromMmapFlags (value, out rval) == 0;
 464                 }
 465
 466                 public static Int32 FromMmapFlags (MmapFlags value)
 467                 {
 468                         Int32 rval;
 469                         if (FromMmapFlags (value, out rval) == -1)
 470                                 ThrowArgumentException (value);
 471                         return rval;
 472                 }
 473
 474                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapFlags")]
 475                 private static extern int ToMmapFlags (Int32 value, out MmapFlags rval);
 476
 477                 public static bool TryToMmapFlags (Int32 value, out MmapFlags rval)
 478                 {
 479                         return ToMmapFlags (value, out rval) == 0;
 480                 }
 481
 482                 public static MmapFlags ToMmapFlags (Int32 value)
 483                 {
 484                         MmapFlags rval;
 485                         if (ToMmapFlags (value, out rval) == -1)
 486                                 ThrowArgumentException (value);
 487                         return rval;
 488                 }
 489
 490                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapProts")]
 491                 private static extern int FromMmapProts (MmapProts value, out Int32 rval);
 492
 493                 public static bool TryFromMmapProts (MmapProts value, out Int32 rval)
 494                 {
 495                         return FromMmapProts (value, out rval) == 0;
 496                 }
 497
 498                 public static Int32 FromMmapProts (MmapProts value)
 499                 {
 500                         Int32 rval;
 501                         if (FromMmapProts (value, out rval) == -1)
 502                                 ThrowArgumentException (value);
 503                         return rval;
 504                 }
 505
 506                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapProts")]
 507                 private static extern int ToMmapProts (Int32 value, out MmapProts rval);
 508
 509                 public static bool TryToMmapProts (Int32 value, out MmapProts rval)
 510                 {
 511                         return ToMmapProts (value, out rval) == 0;
 512                 }
 513
 514                 public static MmapProts ToMmapProts (Int32 value)
 515                 {
 516                         MmapProts rval;
 517                         if (ToMmapProts (value, out rval) == -1)
 518                                 ThrowArgumentException (value);
 519                         return rval;
 520                 }
 521
 522                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMountFlags")]
 523                 private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
 524
 525                 public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
 526                 {
 527                         return FromMountFlags (value, out rval) == 0;
 528                 }
 529
 530                 public static UInt64 FromMountFlags (MountFlags value)
 531                 {
 532                         UInt64 rval;
 533                         if (FromMountFlags (value, out rval) == -1)
 534                                 ThrowArgumentException (value);
 535                         return rval;
 536                 }
 537
 538                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMountFlags")]
 539                 private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
 540
 541                 public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
 542                 {
 543                         return ToMountFlags (value, out rval) == 0;
 544                 }
 545
 546                 public static MountFlags ToMountFlags (UInt64 value)
 547                 {
 548                         MountFlags rval;
 549                         if (ToMountFlags (value, out rval) == -1)
 550                                 ThrowArgumentException (value);
 551                         return rval;
 552                 }
 553
 554                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMremapFlags")]
 555                 private static extern int FromMremapFlags (MremapFlags value, out UInt64 rval);
 556
 557                 public static bool TryFromMremapFlags (MremapFlags value, out UInt64 rval)
 558                 {
 559                         return FromMremapFlags (value, out rval) == 0;
 560                 }
 561
 562                 public static UInt64 FromMremapFlags (MremapFlags value)
 563                 {
 564                         UInt64 rval;
 565                         if (FromMremapFlags (value, out rval) == -1)
 566                                 ThrowArgumentException (value);
 567                         return rval;
 568                 }
 569
 570                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMremapFlags")]
 571                 private static extern int ToMremapFlags (UInt64 value, out MremapFlags rval);
 572
 573                 public static bool TryToMremapFlags (UInt64 value, out MremapFlags rval)
 574                 {
 575                         return ToMremapFlags (value, out rval) == 0;
 576                 }
 577
 578                 public static MremapFlags ToMremapFlags (UInt64 value)
 579                 {
 580                         MremapFlags rval;
 581                         if (ToMremapFlags (value, out rval) == -1)
 582                                 ThrowArgumentException (value);
 583                         return rval;
 584                 }
 585
 586                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMsyncFlags")]
 587                 private static extern int FromMsyncFlags (MsyncFlags value, out Int32 rval);
 588
 589                 public static bool TryFromMsyncFlags (MsyncFlags value, out Int32 rval)
 590                 {
 591                         return FromMsyncFlags (value, out rval) == 0;
 592                 }
 593
 594                 public static Int32 FromMsyncFlags (MsyncFlags value)
 595                 {
 596                         Int32 rval;
 597                         if (FromMsyncFlags (value, out rval) == -1)
 598                                 ThrowArgumentException (value);
 599                         return rval;
 600                 }
 601
 602                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMsyncFlags")]
 603                 private static extern int ToMsyncFlags (Int32 value, out MsyncFlags rval);
 604
 605                 public static bool TryToMsyncFlags (Int32 value, out MsyncFlags rval)
 606                 {
 607                         return ToMsyncFlags (value, out rval) == 0;
 608                 }
 609
 610                 public static MsyncFlags ToMsyncFlags (Int32 value)
 611                 {
 612                         MsyncFlags rval;
 613                         if (ToMsyncFlags (value, out rval) == -1)
 614                                 ThrowArgumentException (value);
 615                         return rval;
 616                 }
 617
 618                 [DllImport (LIB, EntryPoint="Mono_Posix_FromOpenFlags")]
 619                 private static extern int FromOpenFlags (OpenFlags value, out Int32 rval);
 620
 621                 public static bool TryFromOpenFlags (OpenFlags value, out Int32 rval)
 622                 {
 623                         return FromOpenFlags (value, out rval) == 0;
 624                 }
 625
 626                 public static Int32 FromOpenFlags (OpenFlags value)
 627                 {
 628                         Int32 rval;
 629                         if (FromOpenFlags (value, out rval) == -1)
 630                                 ThrowArgumentException (value);
 631                         return rval;
 632                 }
 633
 634                 [DllImport (LIB, EntryPoint="Mono_Posix_ToOpenFlags")]
 635                 private static extern int ToOpenFlags (Int32 value, out OpenFlags rval);
 636
 637                 public static bool TryToOpenFlags (Int32 value, out OpenFlags rval)
 638                 {
 639                         return ToOpenFlags (value, out rval) == 0;
 640                 }
 641
 642                 public static OpenFlags ToOpenFlags (Int32 value)
 643                 {
 644                         OpenFlags rval;
 645                         if (ToOpenFlags (value, out rval) == -1)
 646                                 ThrowArgumentException (value);
 647                         return rval;
 648                 }
 649
 650                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathconfName")]
 651                 private static extern int FromPathconfName (PathconfName value, out Int32 rval);
 652
 653                 public static bool TryFromPathconfName (PathconfName value, out Int32 rval)
 654                 {
 655                         return FromPathconfName (value, out rval) == 0;
 656                 }
 657
 658                 public static Int32 FromPathconfName (PathconfName value)
 659                 {
 660                         Int32 rval;
 661                         if (FromPathconfName (value, out rval) == -1)
 662                                 ThrowArgumentException (value);
 663                         return rval;
 664                 }
 665
 666                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathconfName")]
 667                 private static extern int ToPathconfName (Int32 value, out PathconfName rval);
 668
 669                 public static bool TryToPathconfName (Int32 value, out PathconfName rval)
 670                 {
 671                         return ToPathconfName (value, out rval) == 0;
 672                 }
 673
 674                 public static PathconfName ToPathconfName (Int32 value)
 675                 {
 676                         PathconfName rval;
 677                         if (ToPathconfName (value, out rval) == -1)
 678                                 ThrowArgumentException (value);
 679                         return rval;
 680                 }
 681
 682                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollEvents")]
 683                 private static extern int FromPollEvents (PollEvents value, out Int16 rval);
 684
 685                 public static bool TryFromPollEvents (PollEvents value, out Int16 rval)
 686                 {
 687                         return FromPollEvents (value, out rval) == 0;
 688                 }
 689
 690                 public static Int16 FromPollEvents (PollEvents value)
 691                 {
 692                         Int16 rval;
 693                         if (FromPollEvents (value, out rval) == -1)
 694                                 ThrowArgumentException (value);
 695                         return rval;
 696                 }
 697
 698                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollEvents")]
 699                 private static extern int ToPollEvents (Int16 value, out PollEvents rval);
 700
 701                 public static bool TryToPollEvents (Int16 value, out PollEvents rval)
 702                 {
 703                         return ToPollEvents (value, out rval) == 0;
 704                 }
 705
 706                 public static PollEvents ToPollEvents (Int16 value)
 707                 {
 708                         PollEvents rval;
 709                         if (ToPollEvents (value, out rval) == -1)
 710                                 ThrowArgumentException (value);
 711                         return rval;
 712                 }
 713
 714                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixFadviseAdvice")]
 715                 private static extern int FromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval);
 716
 717                 public static bool TryFromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval)
 718                 {
 719                         return FromPosixFadviseAdvice (value, out rval) == 0;
 720                 }
 721
 722                 public static Int32 FromPosixFadviseAdvice (PosixFadviseAdvice value)
 723                 {
 724                         Int32 rval;
 725                         if (FromPosixFadviseAdvice (value, out rval) == -1)
 726                                 ThrowArgumentException (value);
 727                         return rval;
 728                 }
 729
 730                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixFadviseAdvice")]
 731                 private static extern int ToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval);
 732
 733                 public static bool TryToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval)
 734                 {
 735                         return ToPosixFadviseAdvice (value, out rval) == 0;
 736                 }
 737
 738                 public static PosixFadviseAdvice ToPosixFadviseAdvice (Int32 value)
 739                 {
 740                         PosixFadviseAdvice rval;
 741                         if (ToPosixFadviseAdvice (value, out rval) == -1)
 742                                 ThrowArgumentException (value);
 743                         return rval;
 744                 }
 745
 746                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixMadviseAdvice")]
 747                 private static extern int FromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval);
 748
 749                 public static bool TryFromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval)
 750                 {
 751                         return FromPosixMadviseAdvice (value, out rval) == 0;
 752                 }
 753
 754                 public static Int32 FromPosixMadviseAdvice (PosixMadviseAdvice value)
 755                 {
 756                         Int32 rval;
 757                         if (FromPosixMadviseAdvice (value, out rval) == -1)
 758                                 ThrowArgumentException (value);
 759                         return rval;
 760                 }
 761
 762                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixMadviseAdvice")]
 763                 private static extern int ToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval);
 764
 765                 public static bool TryToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval)
 766                 {
 767                         return ToPosixMadviseAdvice (value, out rval) == 0;
 768                 }
 769
 770                 public static PosixMadviseAdvice ToPosixMadviseAdvice (Int32 value)
 771                 {
 772                         PosixMadviseAdvice rval;
 773                         if (ToPosixMadviseAdvice (value, out rval) == -1)
 774                                 ThrowArgumentException (value);
 775                         return rval;
 776                 }
 777
 778                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSeekFlags")]
 779                 private static extern int FromSeekFlags (SeekFlags value, out Int16 rval);
 780
 781                 public static bool TryFromSeekFlags (SeekFlags value, out Int16 rval)
 782                 {
 783                         return FromSeekFlags (value, out rval) == 0;
 784                 }
 785
 786                 public static Int16 FromSeekFlags (SeekFlags value)
 787                 {
 788                         Int16 rval;
 789                         if (FromSeekFlags (value, out rval) == -1)
 790                                 ThrowArgumentException (value);
 791                         return rval;
 792                 }
 793
 794                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSeekFlags")]
 795                 private static extern int ToSeekFlags (Int16 value, out SeekFlags rval);
 796
 797                 public static bool TryToSeekFlags (Int16 value, out SeekFlags rval)
 798                 {
 799                         return ToSeekFlags (value, out rval) == 0;
 800                 }
 801
 802                 public static SeekFlags ToSeekFlags (Int16 value)
 803                 {
 804                         SeekFlags rval;
 805                         if (ToSeekFlags (value, out rval) == -1)
 806                                 ThrowArgumentException (value);
 807                         return rval;
 808                 }
 809
 810                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSignum")]
 811                 private static extern int FromSignum (Signum value, out Int32 rval);
 812
 813                 public static bool TryFromSignum (Signum value, out Int32 rval)
 814                 {
 815                         return FromSignum (value, out rval) == 0;
 816                 }
 817
 818                 public static Int32 FromSignum (Signum value)
 819                 {
 820                         Int32 rval;
 821                         if (FromSignum (value, out rval) == -1)
 822                                 ThrowArgumentException (value);
 823                         return rval;
 824                 }
 825
 826                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSignum")]
 827                 private static extern int ToSignum (Int32 value, out Signum rval);
 828
 829                 public static bool TryToSignum (Int32 value, out Signum rval)
 830                 {
 831                         return ToSignum (value, out rval) == 0;
 832                 }
 833
 834                 public static Signum ToSignum (Int32 value)
 835                 {
 836                         Signum rval;
 837                         if (ToSignum (value, out rval) == -1)
 838                                 ThrowArgumentException (value);
 839                         return rval;
 840                 }
 841
 842                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysconfName")]
 843                 private static extern int FromSysconfName (SysconfName value, out Int32 rval);
 844
 845                 public static bool TryFromSysconfName (SysconfName value, out Int32 rval)
 846                 {
 847                         return FromSysconfName (value, out rval) == 0;
 848                 }
 849
 850                 public static Int32 FromSysconfName (SysconfName value)
 851                 {
 852                         Int32 rval;
 853                         if (FromSysconfName (value, out rval) == -1)
 854                                 ThrowArgumentException (value);
 855                         return rval;
 856                 }
 857
 858                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysconfName")]
 859                 private static extern int ToSysconfName (Int32 value, out SysconfName rval);
 860
 861                 public static bool TryToSysconfName (Int32 value, out SysconfName rval)
 862                 {
 863                         return ToSysconfName (value, out rval) == 0;
 864                 }
 865
 866                 public static SysconfName ToSysconfName (Int32 value)
 867                 {
 868                         SysconfName rval;
 869                         if (ToSysconfName (value, out rval) == -1)
 870                                 ThrowArgumentException (value);
 871                         return rval;
 872                 }
 873
 874                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogFacility")]
 875                 private static extern int FromSyslogFacility (SyslogFacility value, out Int32 rval);
 876
 877                 public static bool TryFromSyslogFacility (SyslogFacility value, out Int32 rval)
 878                 {
 879                         return FromSyslogFacility (value, out rval) == 0;
 880                 }
 881
 882                 public static Int32 FromSyslogFacility (SyslogFacility value)
 883                 {
 884                         Int32 rval;
 885                         if (FromSyslogFacility (value, out rval) == -1)
 886                                 ThrowArgumentException (value);
 887                         return rval;
 888                 }
 889
 890                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogFacility")]
 891                 private static extern int ToSyslogFacility (Int32 value, out SyslogFacility rval);
 892
 893                 public static bool TryToSyslogFacility (Int32 value, out SyslogFacility rval)
 894                 {
 895                         return ToSyslogFacility (value, out rval) == 0;
 896                 }
 897
 898                 public static SyslogFacility ToSyslogFacility (Int32 value)
 899                 {
 900                         SyslogFacility rval;
 901                         if (ToSyslogFacility (value, out rval) == -1)
 902                                 ThrowArgumentException (value);
 903                         return rval;
 904                 }
 905
 906                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogLevel")]
 907                 private static extern int FromSyslogLevel (SyslogLevel value, out Int32 rval);
 908
 909                 public static bool TryFromSyslogLevel (SyslogLevel value, out Int32 rval)
 910                 {
 911                         return FromSyslogLevel (value, out rval) == 0;
 912                 }
 913
 914                 public static Int32 FromSyslogLevel (SyslogLevel value)
 915                 {
 916                         Int32 rval;
 917                         if (FromSyslogLevel (value, out rval) == -1)
 918                                 ThrowArgumentException (value);
 919                         return rval;
 920                 }
 921
 922                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogLevel")]
 923                 private static extern int ToSyslogLevel (Int32 value, out SyslogLevel rval);
 924
 925                 public static bool TryToSyslogLevel (Int32 value, out SyslogLevel rval)
 926                 {
 927                         return ToSyslogLevel (value, out rval) == 0;
 928                 }
 929
 930                 public static SyslogLevel ToSyslogLevel (Int32 value)
 931                 {
 932                         SyslogLevel rval;
 933                         if (ToSyslogLevel (value, out rval) == -1)
 934                                 ThrowArgumentException (value);
 935                         return rval;
 936                 }
 937
 938                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogOptions")]
 939                 private static extern int FromSyslogOptions (SyslogOptions value, out Int32 rval);
 940
 941                 public static bool TryFromSyslogOptions (SyslogOptions value, out Int32 rval)
 942                 {
 943                         return FromSyslogOptions (value, out rval) == 0;
 944                 }
 945
 946                 public static Int32 FromSyslogOptions (SyslogOptions value)
 947                 {
 948                         Int32 rval;
 949                         if (FromSyslogOptions (value, out rval) == -1)
 950                                 ThrowArgumentException (value);
 951                         return rval;
 952                 }
 953
 954                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogOptions")]
 955                 private static extern int ToSyslogOptions (Int32 value, out SyslogOptions rval);
 956
 957                 public static bool TryToSyslogOptions (Int32 value, out SyslogOptions rval)
 958                 {
 959                         return ToSyslogOptions (value, out rval) == 0;
 960                 }
 961
 962                 public static SyslogOptions ToSyslogOptions (Int32 value)
 963                 {
 964                         SyslogOptions rval;
 965                         if (ToSyslogOptions (value, out rval) == -1)
 966                                 ThrowArgumentException (value);
 967                         return rval;
 968                 }
 969
 970                 [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
 971                 private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);
 972
 973                 public static bool TryFromWaitOptions (WaitOptions value, out Int32 rval)
 974                 {
 975                         return FromWaitOptions (value, out rval) == 0;
 976                 }
 977
 978                 public static Int32 FromWaitOptions (WaitOptions value)
 979                 {
 980                         Int32 rval;
 981                         if (FromWaitOptions (value, out rval) == -1)
 982                                 ThrowArgumentException (value);
 983                         return rval;
 984                 }
 985
 986                 [DllImport (LIB, EntryPoint="Mono_Posix_ToWaitOptions")]
 987                 private static extern int ToWaitOptions (Int32 value, out WaitOptions rval);
 988
 989                 public static bool TryToWaitOptions (Int32 value, out WaitOptions rval)
 990                 {
 991                         return ToWaitOptions (value, out rval) == 0;
 992                 }
 993
 994                 public static WaitOptions ToWaitOptions (Int32 value)
 995                 {
 996                         WaitOptions rval;
 997                         if (ToWaitOptions (value, out rval) == -1)
 998                                 ThrowArgumentException (value);
 999                         return rval;
1000                 }
1001
1002                 [DllImport (LIB, EntryPoint="Mono_Posix_FromXattrFlags")]
1003                 private static extern int FromXattrFlags (XattrFlags value, out Int32 rval);
1004
1005                 public static bool TryFromXattrFlags (XattrFlags value, out Int32 rval)
1006                 {
1007                         return FromXattrFlags (value, out rval) == 0;
1008                 }
1009
1010                 public static Int32 FromXattrFlags (XattrFlags value)
1011                 {
1012                         Int32 rval;
1013                         if (FromXattrFlags (value, out rval) == -1)
1014                                 ThrowArgumentException (value);
1015                         return rval;
1016                 }
1017
1018                 [DllImport (LIB, EntryPoint="Mono_Posix_ToXattrFlags")]
1019                 private static extern int ToXattrFlags (Int32 value, out XattrFlags rval);
1020
1021                 public static bool TryToXattrFlags (Int32 value, out XattrFlags rval)
1022                 {
1023                         return ToXattrFlags (value, out rval) == 0;
1024                 }
1025
1026                 public static XattrFlags ToXattrFlags (Int32 value)
1027                 {
1028                         XattrFlags rval;
1029                         if (ToXattrFlags (value, out rval) == -1)
1030                                 ThrowArgumentException (value);
1031                         return rval;
1032                 }
1033
1034                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathConf")]
1035                 private static extern int FromPathConf (PathConf value, out Int32 rval);
1036
1037                 [Obsolete ("Use Mono.Unix.Native.PathconfName")]
1038                 public static bool TryFromPathConf (PathConf value, out Int32 rval)
1039                 {
1040                         return FromPathConf (value, out rval) == 0;
1041                 }
1042
1043                 [Obsolete ("Use Mono.Unix.Native.PathconfName")]
1044                 public static Int32 FromPathConf (PathConf value)
1045                 {
1046                         Int32 rval;
1047                         if (FromPathConf (value, out rval) == -1)
1048                                 ThrowArgumentException (value);
1049                         return rval;
1050                 }
1051
1052                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathConf")]
1053                 private static extern int ToPathConf (Int32 value, out PathConf rval);
1054
1055                 [Obsolete ("Use Mono.Unix.Native.PathconfName")]
1056                 public static bool TryToPathConf (Int32 value, out PathConf rval)
1057                 {
1058                         return ToPathConf (value, out rval) == 0;
1059                 }
1060
1061                 [Obsolete ("Use Mono.Unix.Native.PathconfName")]
1062                 public static PathConf ToPathConf (Int32 value)
1063                 {
1064                         PathConf rval;
1065                         if (ToPathConf (value, out rval) == -1)
1066                                 ThrowArgumentException (value);
1067                         return rval;
1068                 }
1069
1070                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysConf")]
1071                 private static extern int FromSysConf (SysConf value, out Int32 rval);
1072
1073                 [Obsolete ("Use Mono.Unix.Native.SysconfName")]
1074                 public static bool TryFromSysConf (SysConf value, out Int32 rval)
1075                 {
1076                         return FromSysConf (value, out rval) == 0;
1077                 }
1078
1079                 [Obsolete ("Use Mono.Unix.Native.SysconfName")]
1080                 public static Int32 FromSysConf (SysConf value)
1081                 {
1082                         Int32 rval;
1083                         if (FromSysConf (value, out rval) == -1)
1084                                 ThrowArgumentException (value);
1085                         return rval;
1086                 }
1087
1088                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysConf")]
1089                 private static extern int ToSysConf (Int32 value, out SysConf rval);
1090
1091                 [Obsolete ("Use Mono.Unix.Native.SysconfName")]
1092                 public static bool TryToSysConf (Int32 value, out SysConf rval)
1093                 {
1094                         return ToSysConf (value, out rval) == 0;
1095                 }
1096
1097                 [Obsolete ("Use Mono.Unix.Native.SysconfName")]
1098                 public static SysConf ToSysConf (Int32 value)
1099                 {
1100                         SysConf rval;
1101                         if (ToSysConf (value, out rval) == -1)
1102                                 ThrowArgumentException (value);
1103                         return rval;
1104                 }
1105
1106         }
1107 }
1108