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