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_FromAccessModes")]
  27                 private static extern int FromAccessModes (AccessModes value, out Int32 rval);
  28
  29                 public static bool TryFromAccessModes (AccessModes value, out Int32 rval)
  30                 {
  31                         return FromAccessModes (value, out rval) == 0;
  32                 }
  33
  34                 public static Int32 FromAccessModes (AccessModes value)
  35                 {
  36                         Int32 rval;
  37                         if (FromAccessModes (value, out rval) == -1)
  38                                 ThrowArgumentException (value);
  39                         return rval;
  40                 }
  41
  42                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessModes")]
  43                 private static extern int ToAccessModes (Int32 value, out AccessModes rval);
  44
  45                 public static bool TryToAccessModes (Int32 value, out AccessModes rval)
  46                 {
  47                         return ToAccessModes (value, out rval) == 0;
  48                 }
  49
  50                 public static AccessModes ToAccessModes (Int32 value)
  51                 {
  52                         AccessModes rval;
  53                         if (ToAccessModes (value, out rval) == -1)
  54                                 ThrowArgumentException (value);
  55                         return rval;
  56                 }
  57
  58                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfstrName")]
  59                 private static extern int FromConfstrName (ConfstrName value, out Int32 rval);
  60
  61                 public static bool TryFromConfstrName (ConfstrName value, out Int32 rval)
  62                 {
  63                         return FromConfstrName (value, out rval) == 0;
  64                 }
  65
  66                 public static Int32 FromConfstrName (ConfstrName value)
  67                 {
  68                         Int32 rval;
  69                         if (FromConfstrName (value, out rval) == -1)
  70                                 ThrowArgumentException (value);
  71                         return rval;
  72                 }
  73
  74                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfstrName")]
  75                 private static extern int ToConfstrName (Int32 value, out ConfstrName rval);
  76
  77                 public static bool TryToConfstrName (Int32 value, out ConfstrName rval)
  78                 {
  79                         return ToConfstrName (value, out rval) == 0;
  80                 }
  81
  82                 public static ConfstrName ToConfstrName (Int32 value)
  83                 {
  84                         ConfstrName rval;
  85                         if (ToConfstrName (value, out rval) == -1)
  86                                 ThrowArgumentException (value);
  87                         return rval;
  88                 }
  89
  90                 [DllImport (LIB, EntryPoint="Mono_Posix_FromDirectoryNotifyFlags")]
  91                 private static extern int FromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval);
  92
  93                 public static bool TryFromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval)
  94                 {
  95                         return FromDirectoryNotifyFlags (value, out rval) == 0;
  96                 }
  97
  98                 public static Int32 FromDirectoryNotifyFlags (DirectoryNotifyFlags value)
  99                 {
 100                         Int32 rval;
 101                         if (FromDirectoryNotifyFlags (value, out rval) == -1)
 102                                 ThrowArgumentException (value);
 103                         return rval;
 104                 }
 105
 106                 [DllImport (LIB, EntryPoint="Mono_Posix_ToDirectoryNotifyFlags")]
 107                 private static extern int ToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval);
 108
 109                 public static bool TryToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval)
 110                 {
 111                         return ToDirectoryNotifyFlags (value, out rval) == 0;
 112                 }
 113
 114                 public static DirectoryNotifyFlags ToDirectoryNotifyFlags (Int32 value)
 115                 {
 116                         DirectoryNotifyFlags rval;
 117                         if (ToDirectoryNotifyFlags (value, out rval) == -1)
 118                                 ThrowArgumentException (value);
 119                         return rval;
 120                 }
 121
 122                 [DllImport (LIB, EntryPoint="Mono_Posix_FromErrno")]
 123                 private static extern int FromErrno (Errno value, out Int32 rval);
 124
 125                 public static bool TryFromErrno (Errno value, out Int32 rval)
 126                 {
 127                         return FromErrno (value, out rval) == 0;
 128                 }
 129
 130                 public static Int32 FromErrno (Errno value)
 131                 {
 132                         Int32 rval;
 133                         if (FromErrno (value, out rval) == -1)
 134                                 ThrowArgumentException (value);
 135                         return rval;
 136                 }
 137
 138                 [DllImport (LIB, EntryPoint="Mono_Posix_ToErrno")]
 139                 private static extern int ToErrno (Int32 value, out Errno rval);
 140
 141                 public static bool TryToErrno (Int32 value, out Errno rval)
 142                 {
 143                         return ToErrno (value, out rval) == 0;
 144                 }
 145
 146                 public static Errno ToErrno (Int32 value)
 147                 {
 148                         Errno rval;
 149                         if (ToErrno (value, out rval) == -1)
 150                                 ThrowArgumentException (value);
 151                         return rval;
 152                 }
 153
 154                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFcntlCommand")]
 155                 private static extern int FromFcntlCommand (FcntlCommand value, out Int32 rval);
 156
 157                 public static bool TryFromFcntlCommand (FcntlCommand value, out Int32 rval)
 158                 {
 159                         return FromFcntlCommand (value, out rval) == 0;
 160                 }
 161
 162                 public static Int32 FromFcntlCommand (FcntlCommand value)
 163                 {
 164                         Int32 rval;
 165                         if (FromFcntlCommand (value, out rval) == -1)
 166                                 ThrowArgumentException (value);
 167                         return rval;
 168                 }
 169
 170                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFcntlCommand")]
 171                 private static extern int ToFcntlCommand (Int32 value, out FcntlCommand rval);
 172
 173                 public static bool TryToFcntlCommand (Int32 value, out FcntlCommand rval)
 174                 {
 175                         return ToFcntlCommand (value, out rval) == 0;
 176                 }
 177
 178                 public static FcntlCommand ToFcntlCommand (Int32 value)
 179                 {
 180                         FcntlCommand rval;
 181                         if (ToFcntlCommand (value, out rval) == -1)
 182                                 ThrowArgumentException (value);
 183                         return rval;
 184                 }
 185
 186                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFilePermissions")]
 187                 private static extern int FromFilePermissions (FilePermissions value, out UInt32 rval);
 188
 189                 public static bool TryFromFilePermissions (FilePermissions value, out UInt32 rval)
 190                 {
 191                         return FromFilePermissions (value, out rval) == 0;
 192                 }
 193
 194                 public static UInt32 FromFilePermissions (FilePermissions value)
 195                 {
 196                         UInt32 rval;
 197                         if (FromFilePermissions (value, out rval) == -1)
 198                                 ThrowArgumentException (value);
 199                         return rval;
 200                 }
 201
 202                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFilePermissions")]
 203                 private static extern int ToFilePermissions (UInt32 value, out FilePermissions rval);
 204
 205                 public static bool TryToFilePermissions (UInt32 value, out FilePermissions rval)
 206                 {
 207                         return ToFilePermissions (value, out rval) == 0;
 208                 }
 209
 210                 public static FilePermissions ToFilePermissions (UInt32 value)
 211                 {
 212                         FilePermissions rval;
 213                         if (ToFilePermissions (value, out rval) == -1)
 214                                 ThrowArgumentException (value);
 215                         return rval;
 216                 }
 217
 218                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 219                 private static extern int FromLockType (LockType value, out Int16 rval);
 220
 221                 public static bool TryFromLockType (LockType value, out Int16 rval)
 222                 {
 223                         return FromLockType (value, out rval) == 0;
 224                 }
 225
 226                 public static Int16 FromLockType (LockType value)
 227                 {
 228                         Int16 rval;
 229                         if (FromLockType (value, out rval) == -1)
 230                                 ThrowArgumentException (value);
 231                         return rval;
 232                 }
 233
 234                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockType")]
 235                 private static extern int ToLockType (Int16 value, out LockType rval);
 236
 237                 public static bool TryToLockType (Int16 value, out LockType rval)
 238                 {
 239                         return ToLockType (value, out rval) == 0;
 240                 }
 241
 242                 public static LockType ToLockType (Int16 value)
 243                 {
 244                         LockType rval;
 245                         if (ToLockType (value, out rval) == -1)
 246                                 ThrowArgumentException (value);
 247                         return rval;
 248                 }
 249
 250                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockfCommand")]
 251                 private static extern int FromLockfCommand (LockfCommand value, out Int32 rval);
 252
 253                 public static bool TryFromLockfCommand (LockfCommand value, out Int32 rval)
 254                 {
 255                         return FromLockfCommand (value, out rval) == 0;
 256                 }
 257
 258                 public static Int32 FromLockfCommand (LockfCommand value)
 259                 {
 260                         Int32 rval;
 261                         if (FromLockfCommand (value, out rval) == -1)
 262                                 ThrowArgumentException (value);
 263                         return rval;
 264                 }
 265
 266                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockfCommand")]
 267                 private static extern int ToLockfCommand (Int32 value, out LockfCommand rval);
 268
 269                 public static bool TryToLockfCommand (Int32 value, out LockfCommand rval)
 270                 {
 271                         return ToLockfCommand (value, out rval) == 0;
 272                 }
 273
 274                 public static LockfCommand ToLockfCommand (Int32 value)
 275                 {
 276                         LockfCommand rval;
 277                         if (ToLockfCommand (value, out rval) == -1)
 278                                 ThrowArgumentException (value);
 279                         return rval;
 280                 }
 281
 282                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMlockallFlags")]
 283                 private static extern int FromMlockallFlags (MlockallFlags value, out Int32 rval);
 284
 285                 public static bool TryFromMlockallFlags (MlockallFlags value, out Int32 rval)
 286                 {
 287                         return FromMlockallFlags (value, out rval) == 0;
 288                 }
 289
 290                 public static Int32 FromMlockallFlags (MlockallFlags value)
 291                 {
 292                         Int32 rval;
 293                         if (FromMlockallFlags (value, out rval) == -1)
 294                                 ThrowArgumentException (value);
 295                         return rval;
 296                 }
 297
 298                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMlockallFlags")]
 299                 private static extern int ToMlockallFlags (Int32 value, out MlockallFlags rval);
 300
 301                 public static bool TryToMlockallFlags (Int32 value, out MlockallFlags rval)
 302                 {
 303                         return ToMlockallFlags (value, out rval) == 0;
 304                 }
 305
 306                 public static MlockallFlags ToMlockallFlags (Int32 value)
 307                 {
 308                         MlockallFlags rval;
 309                         if (ToMlockallFlags (value, out rval) == -1)
 310                                 ThrowArgumentException (value);
 311                         return rval;
 312                 }
 313
 314                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapFlags")]
 315                 private static extern int FromMmapFlags (MmapFlags value, out Int32 rval);
 316
 317                 public static bool TryFromMmapFlags (MmapFlags value, out Int32 rval)
 318                 {
 319                         return FromMmapFlags (value, out rval) == 0;
 320                 }
 321
 322                 public static Int32 FromMmapFlags (MmapFlags value)
 323                 {
 324                         Int32 rval;
 325                         if (FromMmapFlags (value, out rval) == -1)
 326                                 ThrowArgumentException (value);
 327                         return rval;
 328                 }
 329
 330                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapFlags")]
 331                 private static extern int ToMmapFlags (Int32 value, out MmapFlags rval);
 332
 333                 public static bool TryToMmapFlags (Int32 value, out MmapFlags rval)
 334                 {
 335                         return ToMmapFlags (value, out rval) == 0;
 336                 }
 337
 338                 public static MmapFlags ToMmapFlags (Int32 value)
 339                 {
 340                         MmapFlags rval;
 341                         if (ToMmapFlags (value, out rval) == -1)
 342                                 ThrowArgumentException (value);
 343                         return rval;
 344                 }
 345
 346                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapProts")]
 347                 private static extern int FromMmapProts (MmapProts value, out Int32 rval);
 348
 349                 public static bool TryFromMmapProts (MmapProts value, out Int32 rval)
 350                 {
 351                         return FromMmapProts (value, out rval) == 0;
 352                 }
 353
 354                 public static Int32 FromMmapProts (MmapProts value)
 355                 {
 356                         Int32 rval;
 357                         if (FromMmapProts (value, out rval) == -1)
 358                                 ThrowArgumentException (value);
 359                         return rval;
 360                 }
 361
 362                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapProts")]
 363                 private static extern int ToMmapProts (Int32 value, out MmapProts rval);
 364
 365                 public static bool TryToMmapProts (Int32 value, out MmapProts rval)
 366                 {
 367                         return ToMmapProts (value, out rval) == 0;
 368                 }
 369
 370                 public static MmapProts ToMmapProts (Int32 value)
 371                 {
 372                         MmapProts rval;
 373                         if (ToMmapProts (value, out rval) == -1)
 374                                 ThrowArgumentException (value);
 375                         return rval;
 376                 }
 377
 378                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMountFlags")]
 379                 private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
 380
 381                 public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
 382                 {
 383                         return FromMountFlags (value, out rval) == 0;
 384                 }
 385
 386                 public static UInt64 FromMountFlags (MountFlags value)
 387                 {
 388                         UInt64 rval;
 389                         if (FromMountFlags (value, out rval) == -1)
 390                                 ThrowArgumentException (value);
 391                         return rval;
 392                 }
 393
 394                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMountFlags")]
 395                 private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
 396
 397                 public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
 398                 {
 399                         return ToMountFlags (value, out rval) == 0;
 400                 }
 401
 402                 public static MountFlags ToMountFlags (UInt64 value)
 403                 {
 404                         MountFlags rval;
 405                         if (ToMountFlags (value, out rval) == -1)
 406                                 ThrowArgumentException (value);
 407                         return rval;
 408                 }
 409
 410                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMremapFlags")]
 411                 private static extern int FromMremapFlags (MremapFlags value, out UInt64 rval);
 412
 413                 public static bool TryFromMremapFlags (MremapFlags value, out UInt64 rval)
 414                 {
 415                         return FromMremapFlags (value, out rval) == 0;
 416                 }
 417
 418                 public static UInt64 FromMremapFlags (MremapFlags value)
 419                 {
 420                         UInt64 rval;
 421                         if (FromMremapFlags (value, out rval) == -1)
 422                                 ThrowArgumentException (value);
 423                         return rval;
 424                 }
 425
 426                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMremapFlags")]
 427                 private static extern int ToMremapFlags (UInt64 value, out MremapFlags rval);
 428
 429                 public static bool TryToMremapFlags (UInt64 value, out MremapFlags rval)
 430                 {
 431                         return ToMremapFlags (value, out rval) == 0;
 432                 }
 433
 434                 public static MremapFlags ToMremapFlags (UInt64 value)
 435                 {
 436                         MremapFlags rval;
 437                         if (ToMremapFlags (value, out rval) == -1)
 438                                 ThrowArgumentException (value);
 439                         return rval;
 440                 }
 441
 442                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMsyncFlags")]
 443                 private static extern int FromMsyncFlags (MsyncFlags value, out Int32 rval);
 444
 445                 public static bool TryFromMsyncFlags (MsyncFlags value, out Int32 rval)
 446                 {
 447                         return FromMsyncFlags (value, out rval) == 0;
 448                 }
 449
 450                 public static Int32 FromMsyncFlags (MsyncFlags value)
 451                 {
 452                         Int32 rval;
 453                         if (FromMsyncFlags (value, out rval) == -1)
 454                                 ThrowArgumentException (value);
 455                         return rval;
 456                 }
 457
 458                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMsyncFlags")]
 459                 private static extern int ToMsyncFlags (Int32 value, out MsyncFlags rval);
 460
 461                 public static bool TryToMsyncFlags (Int32 value, out MsyncFlags rval)
 462                 {
 463                         return ToMsyncFlags (value, out rval) == 0;
 464                 }
 465
 466                 public static MsyncFlags ToMsyncFlags (Int32 value)
 467                 {
 468                         MsyncFlags rval;
 469                         if (ToMsyncFlags (value, out rval) == -1)
 470                                 ThrowArgumentException (value);
 471                         return rval;
 472                 }
 473
 474                 [DllImport (LIB, EntryPoint="Mono_Posix_FromOpenFlags")]
 475                 private static extern int FromOpenFlags (OpenFlags value, out Int32 rval);
 476
 477                 public static bool TryFromOpenFlags (OpenFlags value, out Int32 rval)
 478                 {
 479                         return FromOpenFlags (value, out rval) == 0;
 480                 }
 481
 482                 public static Int32 FromOpenFlags (OpenFlags value)
 483                 {
 484                         Int32 rval;
 485                         if (FromOpenFlags (value, out rval) == -1)
 486                                 ThrowArgumentException (value);
 487                         return rval;
 488                 }
 489
 490                 [DllImport (LIB, EntryPoint="Mono_Posix_ToOpenFlags")]
 491                 private static extern int ToOpenFlags (Int32 value, out OpenFlags rval);
 492
 493                 public static bool TryToOpenFlags (Int32 value, out OpenFlags rval)
 494                 {
 495                         return ToOpenFlags (value, out rval) == 0;
 496                 }
 497
 498                 public static OpenFlags ToOpenFlags (Int32 value)
 499                 {
 500                         OpenFlags rval;
 501                         if (ToOpenFlags (value, out rval) == -1)
 502                                 ThrowArgumentException (value);
 503                         return rval;
 504                 }
 505
 506                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathconfName")]
 507                 private static extern int FromPathconfName (PathconfName value, out Int32 rval);
 508
 509                 public static bool TryFromPathconfName (PathconfName value, out Int32 rval)
 510                 {
 511                         return FromPathconfName (value, out rval) == 0;
 512                 }
 513
 514                 public static Int32 FromPathconfName (PathconfName value)
 515                 {
 516                         Int32 rval;
 517                         if (FromPathconfName (value, out rval) == -1)
 518                                 ThrowArgumentException (value);
 519                         return rval;
 520                 }
 521
 522                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathconfName")]
 523                 private static extern int ToPathconfName (Int32 value, out PathconfName rval);
 524
 525                 public static bool TryToPathconfName (Int32 value, out PathconfName rval)
 526                 {
 527                         return ToPathconfName (value, out rval) == 0;
 528                 }
 529
 530                 public static PathconfName ToPathconfName (Int32 value)
 531                 {
 532                         PathconfName rval;
 533                         if (ToPathconfName (value, out rval) == -1)
 534                                 ThrowArgumentException (value);
 535                         return rval;
 536                 }
 537
 538                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollEvents")]
 539                 private static extern int FromPollEvents (PollEvents value, out Int16 rval);
 540
 541                 public static bool TryFromPollEvents (PollEvents value, out Int16 rval)
 542                 {
 543                         return FromPollEvents (value, out rval) == 0;
 544                 }
 545
 546                 public static Int16 FromPollEvents (PollEvents value)
 547                 {
 548                         Int16 rval;
 549                         if (FromPollEvents (value, out rval) == -1)
 550                                 ThrowArgumentException (value);
 551                         return rval;
 552                 }
 553
 554                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollEvents")]
 555                 private static extern int ToPollEvents (Int16 value, out PollEvents rval);
 556
 557                 public static bool TryToPollEvents (Int16 value, out PollEvents rval)
 558                 {
 559                         return ToPollEvents (value, out rval) == 0;
 560                 }
 561
 562                 public static PollEvents ToPollEvents (Int16 value)
 563                 {
 564                         PollEvents rval;
 565                         if (ToPollEvents (value, out rval) == -1)
 566                                 ThrowArgumentException (value);
 567                         return rval;
 568                 }
 569
 570                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixFadviseAdvice")]
 571                 private static extern int FromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval);
 572
 573                 public static bool TryFromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval)
 574                 {
 575                         return FromPosixFadviseAdvice (value, out rval) == 0;
 576                 }
 577
 578                 public static Int32 FromPosixFadviseAdvice (PosixFadviseAdvice value)
 579                 {
 580                         Int32 rval;
 581                         if (FromPosixFadviseAdvice (value, out rval) == -1)
 582                                 ThrowArgumentException (value);
 583                         return rval;
 584                 }
 585
 586                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixFadviseAdvice")]
 587                 private static extern int ToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval);
 588
 589                 public static bool TryToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval)
 590                 {
 591                         return ToPosixFadviseAdvice (value, out rval) == 0;
 592                 }
 593
 594                 public static PosixFadviseAdvice ToPosixFadviseAdvice (Int32 value)
 595                 {
 596                         PosixFadviseAdvice rval;
 597                         if (ToPosixFadviseAdvice (value, out rval) == -1)
 598                                 ThrowArgumentException (value);
 599                         return rval;
 600                 }
 601
 602                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixMadviseAdvice")]
 603                 private static extern int FromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval);
 604
 605                 public static bool TryFromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval)
 606                 {
 607                         return FromPosixMadviseAdvice (value, out rval) == 0;
 608                 }
 609
 610                 public static Int32 FromPosixMadviseAdvice (PosixMadviseAdvice value)
 611                 {
 612                         Int32 rval;
 613                         if (FromPosixMadviseAdvice (value, out rval) == -1)
 614                                 ThrowArgumentException (value);
 615                         return rval;
 616                 }
 617
 618                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixMadviseAdvice")]
 619                 private static extern int ToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval);
 620
 621                 public static bool TryToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval)
 622                 {
 623                         return ToPosixMadviseAdvice (value, out rval) == 0;
 624                 }
 625
 626                 public static PosixMadviseAdvice ToPosixMadviseAdvice (Int32 value)
 627                 {
 628                         PosixMadviseAdvice rval;
 629                         if (ToPosixMadviseAdvice (value, out rval) == -1)
 630                                 ThrowArgumentException (value);
 631                         return rval;
 632                 }
 633
 634                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSeekFlags")]
 635                 private static extern int FromSeekFlags (SeekFlags value, out Int16 rval);
 636
 637                 public static bool TryFromSeekFlags (SeekFlags value, out Int16 rval)
 638                 {
 639                         return FromSeekFlags (value, out rval) == 0;
 640                 }
 641
 642                 public static Int16 FromSeekFlags (SeekFlags value)
 643                 {
 644                         Int16 rval;
 645                         if (FromSeekFlags (value, out rval) == -1)
 646                                 ThrowArgumentException (value);
 647                         return rval;
 648                 }
 649
 650                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSeekFlags")]
 651                 private static extern int ToSeekFlags (Int16 value, out SeekFlags rval);
 652
 653                 public static bool TryToSeekFlags (Int16 value, out SeekFlags rval)
 654                 {
 655                         return ToSeekFlags (value, out rval) == 0;
 656                 }
 657
 658                 public static SeekFlags ToSeekFlags (Int16 value)
 659                 {
 660                         SeekFlags rval;
 661                         if (ToSeekFlags (value, out rval) == -1)
 662                                 ThrowArgumentException (value);
 663                         return rval;
 664                 }
 665
 666                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSignum")]
 667                 private static extern int FromSignum (Signum value, out Int32 rval);
 668
 669                 public static bool TryFromSignum (Signum value, out Int32 rval)
 670                 {
 671                         return FromSignum (value, out rval) == 0;
 672                 }
 673
 674                 public static Int32 FromSignum (Signum value)
 675                 {
 676                         Int32 rval;
 677                         if (FromSignum (value, out rval) == -1)
 678                                 ThrowArgumentException (value);
 679                         return rval;
 680                 }
 681
 682                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSignum")]
 683                 private static extern int ToSignum (Int32 value, out Signum rval);
 684
 685                 public static bool TryToSignum (Int32 value, out Signum rval)
 686                 {
 687                         return ToSignum (value, out rval) == 0;
 688                 }
 689
 690                 public static Signum ToSignum (Int32 value)
 691                 {
 692                         Signum rval;
 693                         if (ToSignum (value, out rval) == -1)
 694                                 ThrowArgumentException (value);
 695                         return rval;
 696                 }
 697
 698                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysconfName")]
 699                 private static extern int FromSysconfName (SysconfName value, out Int32 rval);
 700
 701                 public static bool TryFromSysconfName (SysconfName value, out Int32 rval)
 702                 {
 703                         return FromSysconfName (value, out rval) == 0;
 704                 }
 705
 706                 public static Int32 FromSysconfName (SysconfName value)
 707                 {
 708                         Int32 rval;
 709                         if (FromSysconfName (value, out rval) == -1)
 710                                 ThrowArgumentException (value);
 711                         return rval;
 712                 }
 713
 714                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysconfName")]
 715                 private static extern int ToSysconfName (Int32 value, out SysconfName rval);
 716
 717                 public static bool TryToSysconfName (Int32 value, out SysconfName rval)
 718                 {
 719                         return ToSysconfName (value, out rval) == 0;
 720                 }
 721
 722                 public static SysconfName ToSysconfName (Int32 value)
 723                 {
 724                         SysconfName rval;
 725                         if (ToSysconfName (value, out rval) == -1)
 726                                 ThrowArgumentException (value);
 727                         return rval;
 728                 }
 729
 730                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogFacility")]
 731                 private static extern int FromSyslogFacility (SyslogFacility value, out Int32 rval);
 732
 733                 public static bool TryFromSyslogFacility (SyslogFacility value, out Int32 rval)
 734                 {
 735                         return FromSyslogFacility (value, out rval) == 0;
 736                 }
 737
 738                 public static Int32 FromSyslogFacility (SyslogFacility value)
 739                 {
 740                         Int32 rval;
 741                         if (FromSyslogFacility (value, out rval) == -1)
 742                                 ThrowArgumentException (value);
 743                         return rval;
 744                 }
 745
 746                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogFacility")]
 747                 private static extern int ToSyslogFacility (Int32 value, out SyslogFacility rval);
 748
 749                 public static bool TryToSyslogFacility (Int32 value, out SyslogFacility rval)
 750                 {
 751                         return ToSyslogFacility (value, out rval) == 0;
 752                 }
 753
 754                 public static SyslogFacility ToSyslogFacility (Int32 value)
 755                 {
 756                         SyslogFacility rval;
 757                         if (ToSyslogFacility (value, out rval) == -1)
 758                                 ThrowArgumentException (value);
 759                         return rval;
 760                 }
 761
 762                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogLevel")]
 763                 private static extern int FromSyslogLevel (SyslogLevel value, out Int32 rval);
 764
 765                 public static bool TryFromSyslogLevel (SyslogLevel value, out Int32 rval)
 766                 {
 767                         return FromSyslogLevel (value, out rval) == 0;
 768                 }
 769
 770                 public static Int32 FromSyslogLevel (SyslogLevel value)
 771                 {
 772                         Int32 rval;
 773                         if (FromSyslogLevel (value, out rval) == -1)
 774                                 ThrowArgumentException (value);
 775                         return rval;
 776                 }
 777
 778                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogLevel")]
 779                 private static extern int ToSyslogLevel (Int32 value, out SyslogLevel rval);
 780
 781                 public static bool TryToSyslogLevel (Int32 value, out SyslogLevel rval)
 782                 {
 783                         return ToSyslogLevel (value, out rval) == 0;
 784                 }
 785
 786                 public static SyslogLevel ToSyslogLevel (Int32 value)
 787                 {
 788                         SyslogLevel rval;
 789                         if (ToSyslogLevel (value, out rval) == -1)
 790                                 ThrowArgumentException (value);
 791                         return rval;
 792                 }
 793
 794                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogOptions")]
 795                 private static extern int FromSyslogOptions (SyslogOptions value, out Int32 rval);
 796
 797                 public static bool TryFromSyslogOptions (SyslogOptions value, out Int32 rval)
 798                 {
 799                         return FromSyslogOptions (value, out rval) == 0;
 800                 }
 801
 802                 public static Int32 FromSyslogOptions (SyslogOptions value)
 803                 {
 804                         Int32 rval;
 805                         if (FromSyslogOptions (value, out rval) == -1)
 806                                 ThrowArgumentException (value);
 807                         return rval;
 808                 }
 809
 810                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogOptions")]
 811                 private static extern int ToSyslogOptions (Int32 value, out SyslogOptions rval);
 812
 813                 public static bool TryToSyslogOptions (Int32 value, out SyslogOptions rval)
 814                 {
 815                         return ToSyslogOptions (value, out rval) == 0;
 816                 }
 817
 818                 public static SyslogOptions ToSyslogOptions (Int32 value)
 819                 {
 820                         SyslogOptions rval;
 821                         if (ToSyslogOptions (value, out rval) == -1)
 822                                 ThrowArgumentException (value);
 823                         return rval;
 824                 }
 825
 826                 [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
 827                 private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);
 828
 829                 public static bool TryFromWaitOptions (WaitOptions value, out Int32 rval)
 830                 {
 831                         return FromWaitOptions (value, out rval) == 0;
 832                 }
 833
 834                 public static Int32 FromWaitOptions (WaitOptions value)
 835                 {
 836                         Int32 rval;
 837                         if (FromWaitOptions (value, out rval) == -1)
 838                                 ThrowArgumentException (value);
 839                         return rval;
 840                 }
 841
 842                 [DllImport (LIB, EntryPoint="Mono_Posix_ToWaitOptions")]
 843                 private static extern int ToWaitOptions (Int32 value, out WaitOptions rval);
 844
 845                 public static bool TryToWaitOptions (Int32 value, out WaitOptions rval)
 846                 {
 847                         return ToWaitOptions (value, out rval) == 0;
 848                 }
 849
 850                 public static WaitOptions ToWaitOptions (Int32 value)
 851                 {
 852                         WaitOptions rval;
 853                         if (ToWaitOptions (value, out rval) == -1)
 854                                 ThrowArgumentException (value);
 855                         return rval;
 856                 }
 857
 858                 [DllImport (LIB, EntryPoint="Mono_Posix_FromXattrFlags")]
 859                 private static extern int FromXattrFlags (XattrFlags value, out Int32 rval);
 860
 861                 public static bool TryFromXattrFlags (XattrFlags value, out Int32 rval)
 862                 {
 863                         return FromXattrFlags (value, out rval) == 0;
 864                 }
 865
 866                 public static Int32 FromXattrFlags (XattrFlags value)
 867                 {
 868                         Int32 rval;
 869                         if (FromXattrFlags (value, out rval) == -1)
 870                                 ThrowArgumentException (value);
 871                         return rval;
 872                 }
 873
 874                 [DllImport (LIB, EntryPoint="Mono_Posix_ToXattrFlags")]
 875                 private static extern int ToXattrFlags (Int32 value, out XattrFlags rval);
 876
 877                 public static bool TryToXattrFlags (Int32 value, out XattrFlags rval)
 878                 {
 879                         return ToXattrFlags (value, out rval) == 0;
 880                 }
 881
 882                 public static XattrFlags ToXattrFlags (Int32 value)
 883                 {
 884                         XattrFlags rval;
 885                         if (ToXattrFlags (value, out rval) == -1)
 886                                 ThrowArgumentException (value);
 887                         return rval;
 888                 }
 889
 890         }
 891 }
 892