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

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