mcs/class/Mono.Posix/Mono.Unix/UnixConvert.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.IO;
   9 using System.Runtime.InteropServices;
  10 using Mono.Unix;
  11
  12 namespace Mono.Unix {
  13
  14         public sealed /* static */ class UnixConvert
  15         {
  16                 private UnixConvert () {}
  17
  18                 private const string LIB = "MonoPosixHelper";
  19
  20                 private static void ThrowArgumentException (object value)
  21                 {
  22                         throw new ArgumentOutOfRangeException ("value", value,
  23                                 Locale.GetText ("Current platform doesn't support this value."));
  24                 }
  25
  26                 [DllImport (LIB, EntryPoint="Mono_Posix_FromError")]
  27                 private static extern int FromError (Error value, out Int32 rval);
  28
  29                 public static bool TryFromError (Error value, out Int32 rval)
  30                 {
  31                         return FromError (value, out rval) == 0;
  32                 }
  33
  34                 public static Int32 FromError (Error value)
  35                 {
  36                         Int32 rval;
  37                         if (FromError (value, out rval) == -1)
  38                                 ThrowArgumentException (value);
  39                         return rval;
  40                 }
  41
  42                 [DllImport (LIB, EntryPoint="Mono_Posix_ToError")]
  43                 private static extern int ToError (Int32 value, out Error rval);
  44
  45                 public static bool TryToError (Int32 value, out Error rval)
  46                 {
  47                         return ToError (value, out rval) == 0;
  48                 }
  49
  50                 public static Error ToError (Int32 value)
  51                 {
  52                         Error rval;
  53                         if (ToError (value, out rval) == -1)
  54                                 ThrowArgumentException (value);
  55                         return rval;
  56                 }
  57
  58                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogOptions")]
  59                 private static extern int FromSyslogOptions (SyslogOptions value, out Int32 rval);
  60
  61                 public static bool TryFromSyslogOptions (SyslogOptions value, out Int32 rval)
  62                 {
  63                         return FromSyslogOptions (value, out rval) == 0;
  64                 }
  65
  66                 public static Int32 FromSyslogOptions (SyslogOptions value)
  67                 {
  68                         Int32 rval;
  69                         if (FromSyslogOptions (value, out rval) == -1)
  70                                 ThrowArgumentException (value);
  71                         return rval;
  72                 }
  73
  74                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogOptions")]
  75                 private static extern int ToSyslogOptions (Int32 value, out SyslogOptions rval);
  76
  77                 public static bool TryToSyslogOptions (Int32 value, out SyslogOptions rval)
  78                 {
  79                         return ToSyslogOptions (value, out rval) == 0;
  80                 }
  81
  82                 public static SyslogOptions ToSyslogOptions (Int32 value)
  83                 {
  84                         SyslogOptions rval;
  85                         if (ToSyslogOptions (value, out rval) == -1)
  86                                 ThrowArgumentException (value);
  87                         return rval;
  88                 }
  89
  90                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogFacility")]
  91                 private static extern int FromSyslogFacility (SyslogFacility value, out Int32 rval);
  92
  93                 public static bool TryFromSyslogFacility (SyslogFacility value, out Int32 rval)
  94                 {
  95                         return FromSyslogFacility (value, out rval) == 0;
  96                 }
  97
  98                 public static Int32 FromSyslogFacility (SyslogFacility value)
  99                 {
 100                         Int32 rval;
 101                         if (FromSyslogFacility (value, out rval) == -1)
 102                                 ThrowArgumentException (value);
 103                         return rval;
 104                 }
 105
 106                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogFacility")]
 107                 private static extern int ToSyslogFacility (Int32 value, out SyslogFacility rval);
 108
 109                 public static bool TryToSyslogFacility (Int32 value, out SyslogFacility rval)
 110                 {
 111                         return ToSyslogFacility (value, out rval) == 0;
 112                 }
 113
 114                 public static SyslogFacility ToSyslogFacility (Int32 value)
 115                 {
 116                         SyslogFacility rval;
 117                         if (ToSyslogFacility (value, out rval) == -1)
 118                                 ThrowArgumentException (value);
 119                         return rval;
 120                 }
 121
 122                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSyslogLevel")]
 123                 private static extern int FromSyslogLevel (SyslogLevel value, out Int32 rval);
 124
 125                 public static bool TryFromSyslogLevel (SyslogLevel value, out Int32 rval)
 126                 {
 127                         return FromSyslogLevel (value, out rval) == 0;
 128                 }
 129
 130                 public static Int32 FromSyslogLevel (SyslogLevel value)
 131                 {
 132                         Int32 rval;
 133                         if (FromSyslogLevel (value, out rval) == -1)
 134                                 ThrowArgumentException (value);
 135                         return rval;
 136                 }
 137
 138                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSyslogLevel")]
 139                 private static extern int ToSyslogLevel (Int32 value, out SyslogLevel rval);
 140
 141                 public static bool TryToSyslogLevel (Int32 value, out SyslogLevel rval)
 142                 {
 143                         return ToSyslogLevel (value, out rval) == 0;
 144                 }
 145
 146                 public static SyslogLevel ToSyslogLevel (Int32 value)
 147                 {
 148                         SyslogLevel rval;
 149                         if (ToSyslogLevel (value, out rval) == -1)
 150                                 ThrowArgumentException (value);
 151                         return rval;
 152                 }
 153
 154                 [DllImport (LIB, EntryPoint="Mono_Posix_FromOpenFlags")]
 155                 private static extern int FromOpenFlags (OpenFlags value, out Int32 rval);
 156
 157                 public static bool TryFromOpenFlags (OpenFlags value, out Int32 rval)
 158                 {
 159                         return FromOpenFlags (value, out rval) == 0;
 160                 }
 161
 162                 public static Int32 FromOpenFlags (OpenFlags value)
 163                 {
 164                         Int32 rval;
 165                         if (FromOpenFlags (value, out rval) == -1)
 166                                 ThrowArgumentException (value);
 167                         return rval;
 168                 }
 169
 170                 [DllImport (LIB, EntryPoint="Mono_Posix_ToOpenFlags")]
 171                 private static extern int ToOpenFlags (Int32 value, out OpenFlags rval);
 172
 173                 public static bool TryToOpenFlags (Int32 value, out OpenFlags rval)
 174                 {
 175                         return ToOpenFlags (value, out rval) == 0;
 176                 }
 177
 178                 public static OpenFlags ToOpenFlags (Int32 value)
 179                 {
 180                         OpenFlags rval;
 181                         if (ToOpenFlags (value, out rval) == -1)
 182                                 ThrowArgumentException (value);
 183                         return rval;
 184                 }
 185
 186                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFilePermissions")]
 187                 private static extern int FromFilePermissions (FilePermissions value, out UInt32 rval);
 188
 189                 public static bool TryFromFilePermissions (FilePermissions value, out UInt32 rval)
 190                 {
 191                         return FromFilePermissions (value, out rval) == 0;
 192                 }
 193
 194                 public static UInt32 FromFilePermissions (FilePermissions value)
 195                 {
 196                         UInt32 rval;
 197                         if (FromFilePermissions (value, out rval) == -1)
 198                                 ThrowArgumentException (value);
 199                         return rval;
 200                 }
 201
 202                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFilePermissions")]
 203                 private static extern int ToFilePermissions (UInt32 value, out FilePermissions rval);
 204
 205                 public static bool TryToFilePermissions (UInt32 value, out FilePermissions rval)
 206                 {
 207                         return ToFilePermissions (value, out rval) == 0;
 208                 }
 209
 210                 public static FilePermissions ToFilePermissions (UInt32 value)
 211                 {
 212                         FilePermissions rval;
 213                         if (ToFilePermissions (value, out rval) == -1)
 214                                 ThrowArgumentException (value);
 215                         return rval;
 216                 }
 217
 218                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFcntlCommand")]
 219                 private static extern int FromFcntlCommand (FcntlCommand value, out Int32 rval);
 220
 221                 public static bool TryFromFcntlCommand (FcntlCommand value, out Int32 rval)
 222                 {
 223                         return FromFcntlCommand (value, out rval) == 0;
 224                 }
 225
 226                 public static Int32 FromFcntlCommand (FcntlCommand value)
 227                 {
 228                         Int32 rval;
 229                         if (FromFcntlCommand (value, out rval) == -1)
 230                                 ThrowArgumentException (value);
 231                         return rval;
 232                 }
 233
 234                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFcntlCommand")]
 235                 private static extern int ToFcntlCommand (Int32 value, out FcntlCommand rval);
 236
 237                 public static bool TryToFcntlCommand (Int32 value, out FcntlCommand rval)
 238                 {
 239                         return ToFcntlCommand (value, out rval) == 0;
 240                 }
 241
 242                 public static FcntlCommand ToFcntlCommand (Int32 value)
 243                 {
 244                         FcntlCommand rval;
 245                         if (ToFcntlCommand (value, out rval) == -1)
 246                                 ThrowArgumentException (value);
 247                         return rval;
 248                 }
 249
 250                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 251                 private static extern int FromLockType (LockType value, out Int16 rval);
 252
 253                 public static bool TryFromLockType (LockType value, out Int16 rval)
 254                 {
 255                         return FromLockType (value, out rval) == 0;
 256                 }
 257
 258                 public static Int16 FromLockType (LockType value)
 259                 {
 260                         Int16 rval;
 261                         if (FromLockType (value, out rval) == -1)
 262                                 ThrowArgumentException (value);
 263                         return rval;
 264                 }
 265
 266                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockType")]
 267                 private static extern int ToLockType (Int16 value, out LockType rval);
 268
 269                 public static bool TryToLockType (Int16 value, out LockType rval)
 270                 {
 271                         return ToLockType (value, out rval) == 0;
 272                 }
 273
 274                 public static LockType ToLockType (Int16 value)
 275                 {
 276                         LockType rval;
 277                         if (ToLockType (value, out rval) == -1)
 278                                 ThrowArgumentException (value);
 279                         return rval;
 280                 }
 281
 282                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSeekFlags")]
 283                 private static extern int FromSeekFlags (SeekFlags value, out Int16 rval);
 284
 285                 public static bool TryFromSeekFlags (SeekFlags value, out Int16 rval)
 286                 {
 287                         return FromSeekFlags (value, out rval) == 0;
 288                 }
 289
 290                 public static Int16 FromSeekFlags (SeekFlags value)
 291                 {
 292                         Int16 rval;
 293                         if (FromSeekFlags (value, out rval) == -1)
 294                                 ThrowArgumentException (value);
 295                         return rval;
 296                 }
 297
 298                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSeekFlags")]
 299                 private static extern int ToSeekFlags (Int16 value, out SeekFlags rval);
 300
 301                 public static bool TryToSeekFlags (Int16 value, out SeekFlags rval)
 302                 {
 303                         return ToSeekFlags (value, out rval) == 0;
 304                 }
 305
 306                 public static SeekFlags ToSeekFlags (Int16 value)
 307                 {
 308                         SeekFlags rval;
 309                         if (ToSeekFlags (value, out rval) == -1)
 310                                 ThrowArgumentException (value);
 311                         return rval;
 312                 }
 313
 314                 [DllImport (LIB, EntryPoint="Mono_Posix_FromDirectoryNotifyFlags")]
 315                 private static extern int FromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval);
 316
 317                 public static bool TryFromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval)
 318                 {
 319                         return FromDirectoryNotifyFlags (value, out rval) == 0;
 320                 }
 321
 322                 public static Int32 FromDirectoryNotifyFlags (DirectoryNotifyFlags value)
 323                 {
 324                         Int32 rval;
 325                         if (FromDirectoryNotifyFlags (value, out rval) == -1)
 326                                 ThrowArgumentException (value);
 327                         return rval;
 328                 }
 329
 330                 [DllImport (LIB, EntryPoint="Mono_Posix_ToDirectoryNotifyFlags")]
 331                 private static extern int ToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval);
 332
 333                 public static bool TryToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval)
 334                 {
 335                         return ToDirectoryNotifyFlags (value, out rval) == 0;
 336                 }
 337
 338                 public static DirectoryNotifyFlags ToDirectoryNotifyFlags (Int32 value)
 339                 {
 340                         DirectoryNotifyFlags rval;
 341                         if (ToDirectoryNotifyFlags (value, out rval) == -1)
 342                                 ThrowArgumentException (value);
 343                         return rval;
 344                 }
 345
 346                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixFadviseAdvice")]
 347                 private static extern int FromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval);
 348
 349                 public static bool TryFromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval)
 350                 {
 351                         return FromPosixFadviseAdvice (value, out rval) == 0;
 352                 }
 353
 354                 public static Int32 FromPosixFadviseAdvice (PosixFadviseAdvice value)
 355                 {
 356                         Int32 rval;
 357                         if (FromPosixFadviseAdvice (value, out rval) == -1)
 358                                 ThrowArgumentException (value);
 359                         return rval;
 360                 }
 361
 362                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixFadviseAdvice")]
 363                 private static extern int ToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval);
 364
 365                 public static bool TryToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval)
 366                 {
 367                         return ToPosixFadviseAdvice (value, out rval) == 0;
 368                 }
 369
 370                 public static PosixFadviseAdvice ToPosixFadviseAdvice (Int32 value)
 371                 {
 372                         PosixFadviseAdvice rval;
 373                         if (ToPosixFadviseAdvice (value, out rval) == -1)
 374                                 ThrowArgumentException (value);
 375                         return rval;
 376                 }
 377
 378                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixMadviseAdvice")]
 379                 private static extern int FromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval);
 380
 381                 public static bool TryFromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval)
 382                 {
 383                         return FromPosixMadviseAdvice (value, out rval) == 0;
 384                 }
 385
 386                 public static Int32 FromPosixMadviseAdvice (PosixMadviseAdvice value)
 387                 {
 388                         Int32 rval;
 389                         if (FromPosixMadviseAdvice (value, out rval) == -1)
 390                                 ThrowArgumentException (value);
 391                         return rval;
 392                 }
 393
 394                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixMadviseAdvice")]
 395                 private static extern int ToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval);
 396
 397                 public static bool TryToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval)
 398                 {
 399                         return ToPosixMadviseAdvice (value, out rval) == 0;
 400                 }
 401
 402                 public static PosixMadviseAdvice ToPosixMadviseAdvice (Int32 value)
 403                 {
 404                         PosixMadviseAdvice rval;
 405                         if (ToPosixMadviseAdvice (value, out rval) == -1)
 406                                 ThrowArgumentException (value);
 407                         return rval;
 408                 }
 409
 410                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSignum")]
 411                 private static extern int FromSignum (Signum value, out Int32 rval);
 412
 413                 public static bool TryFromSignum (Signum value, out Int32 rval)
 414                 {
 415                         return FromSignum (value, out rval) == 0;
 416                 }
 417
 418                 public static Int32 FromSignum (Signum value)
 419                 {
 420                         Int32 rval;
 421                         if (FromSignum (value, out rval) == -1)
 422                                 ThrowArgumentException (value);
 423                         return rval;
 424                 }
 425
 426                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSignum")]
 427                 private static extern int ToSignum (Int32 value, out Signum rval);
 428
 429                 public static bool TryToSignum (Int32 value, out Signum rval)
 430                 {
 431                         return ToSignum (value, out rval) == 0;
 432                 }
 433
 434                 public static Signum ToSignum (Int32 value)
 435                 {
 436                         Signum rval;
 437                         if (ToSignum (value, out rval) == -1)
 438                                 ThrowArgumentException (value);
 439                         return rval;
 440                 }
 441
 442                 [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
 443                 private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);
 444
 445                 public static bool TryFromWaitOptions (WaitOptions value, out Int32 rval)
 446                 {
 447                         return FromWaitOptions (value, out rval) == 0;
 448                 }
 449
 450                 public static Int32 FromWaitOptions (WaitOptions value)
 451                 {
 452                         Int32 rval;
 453                         if (FromWaitOptions (value, out rval) == -1)
 454                                 ThrowArgumentException (value);
 455                         return rval;
 456                 }
 457
 458                 [DllImport (LIB, EntryPoint="Mono_Posix_ToWaitOptions")]
 459                 private static extern int ToWaitOptions (Int32 value, out WaitOptions rval);
 460
 461                 public static bool TryToWaitOptions (Int32 value, out WaitOptions rval)
 462                 {
 463                         return ToWaitOptions (value, out rval) == 0;
 464                 }
 465
 466                 public static WaitOptions ToWaitOptions (Int32 value)
 467                 {
 468                         WaitOptions rval;
 469                         if (ToWaitOptions (value, out rval) == -1)
 470                                 ThrowArgumentException (value);
 471                         return rval;
 472                 }
 473
 474                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAccessMode")]
 475                 private static extern int FromAccessMode (AccessMode value, out Int32 rval);
 476
 477                 public static bool TryFromAccessMode (AccessMode value, out Int32 rval)
 478                 {
 479                         return FromAccessMode (value, out rval) == 0;
 480                 }
 481
 482                 public static Int32 FromAccessMode (AccessMode value)
 483                 {
 484                         Int32 rval;
 485                         if (FromAccessMode (value, out rval) == -1)
 486                                 ThrowArgumentException (value);
 487                         return rval;
 488                 }
 489
 490                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessMode")]
 491                 private static extern int ToAccessMode (Int32 value, out AccessMode rval);
 492
 493                 public static bool TryToAccessMode (Int32 value, out AccessMode rval)
 494                 {
 495                         return ToAccessMode (value, out rval) == 0;
 496                 }
 497
 498                 public static AccessMode ToAccessMode (Int32 value)
 499                 {
 500                         AccessMode rval;
 501                         if (ToAccessMode (value, out rval) == -1)
 502                                 ThrowArgumentException (value);
 503                         return rval;
 504                 }
 505
 506                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathConf")]
 507                 private static extern int FromPathConf (PathConf value, out Int32 rval);
 508
 509                 public static bool TryFromPathConf (PathConf value, out Int32 rval)
 510                 {
 511                         return FromPathConf (value, out rval) == 0;
 512                 }
 513
 514                 public static Int32 FromPathConf (PathConf value)
 515                 {
 516                         Int32 rval;
 517                         if (FromPathConf (value, out rval) == -1)
 518                                 ThrowArgumentException (value);
 519                         return rval;
 520                 }
 521
 522                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathConf")]
 523                 private static extern int ToPathConf (Int32 value, out PathConf rval);
 524
 525                 public static bool TryToPathConf (Int32 value, out PathConf rval)
 526                 {
 527                         return ToPathConf (value, out rval) == 0;
 528                 }
 529
 530                 public static PathConf ToPathConf (Int32 value)
 531                 {
 532                         PathConf rval;
 533                         if (ToPathConf (value, out rval) == -1)
 534                                 ThrowArgumentException (value);
 535                         return rval;
 536                 }
 537
 538                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysConf")]
 539                 private static extern int FromSysConf (SysConf value, out Int32 rval);
 540
 541                 public static bool TryFromSysConf (SysConf value, out Int32 rval)
 542                 {
 543                         return FromSysConf (value, out rval) == 0;
 544                 }
 545
 546                 public static Int32 FromSysConf (SysConf value)
 547                 {
 548                         Int32 rval;
 549                         if (FromSysConf (value, out rval) == -1)
 550                                 ThrowArgumentException (value);
 551                         return rval;
 552                 }
 553
 554                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysConf")]
 555                 private static extern int ToSysConf (Int32 value, out SysConf rval);
 556
 557                 public static bool TryToSysConf (Int32 value, out SysConf rval)
 558                 {
 559                         return ToSysConf (value, out rval) == 0;
 560                 }
 561
 562                 public static SysConf ToSysConf (Int32 value)
 563                 {
 564                         SysConf rval;
 565                         if (ToSysConf (value, out rval) == -1)
 566                                 ThrowArgumentException (value);
 567                         return rval;
 568                 }
 569
 570                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfStr")]
 571                 private static extern int FromConfStr (ConfStr value, out Int32 rval);
 572
 573                 public static bool TryFromConfStr (ConfStr value, out Int32 rval)
 574                 {
 575                         return FromConfStr (value, out rval) == 0;
 576                 }
 577
 578                 public static Int32 FromConfStr (ConfStr value)
 579                 {
 580                         Int32 rval;
 581                         if (FromConfStr (value, out rval) == -1)
 582                                 ThrowArgumentException (value);
 583                         return rval;
 584                 }
 585
 586                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfStr")]
 587                 private static extern int ToConfStr (Int32 value, out ConfStr rval);
 588
 589                 public static bool TryToConfStr (Int32 value, out ConfStr rval)
 590                 {
 591                         return ToConfStr (value, out rval) == 0;
 592                 }
 593
 594                 public static ConfStr ToConfStr (Int32 value)
 595                 {
 596                         ConfStr rval;
 597                         if (ToConfStr (value, out rval) == -1)
 598                                 ThrowArgumentException (value);
 599                         return rval;
 600                 }
 601
 602                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockFlags")]
 603                 private static extern int FromLockFlags (LockFlags value, out Int32 rval);
 604
 605                 public static bool TryFromLockFlags (LockFlags value, out Int32 rval)
 606                 {
 607                         return FromLockFlags (value, out rval) == 0;
 608                 }
 609
 610                 public static Int32 FromLockFlags (LockFlags value)
 611                 {
 612                         Int32 rval;
 613                         if (FromLockFlags (value, out rval) == -1)
 614                                 ThrowArgumentException (value);
 615                         return rval;
 616                 }
 617
 618                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockFlags")]
 619                 private static extern int ToLockFlags (Int32 value, out LockFlags rval);
 620
 621                 public static bool TryToLockFlags (Int32 value, out LockFlags rval)
 622                 {
 623                         return ToLockFlags (value, out rval) == 0;
 624                 }
 625
 626                 public static LockFlags ToLockFlags (Int32 value)
 627                 {
 628                         LockFlags rval;
 629                         if (ToLockFlags (value, out rval) == -1)
 630                                 ThrowArgumentException (value);
 631                         return rval;
 632                 }
 633
 634                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollEvents")]
 635                 private static extern int FromPollEvents (PollEvents value, out Int16 rval);
 636
 637                 public static bool TryFromPollEvents (PollEvents value, out Int16 rval)
 638                 {
 639                         return FromPollEvents (value, out rval) == 0;
 640                 }
 641
 642                 public static Int16 FromPollEvents (PollEvents value)
 643                 {
 644                         Int16 rval;
 645                         if (FromPollEvents (value, out rval) == -1)
 646                                 ThrowArgumentException (value);
 647                         return rval;
 648                 }
 649
 650                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollEvents")]
 651                 private static extern int ToPollEvents (Int16 value, out PollEvents rval);
 652
 653                 public static bool TryToPollEvents (Int16 value, out PollEvents rval)
 654                 {
 655                         return ToPollEvents (value, out rval) == 0;
 656                 }
 657
 658                 public static PollEvents ToPollEvents (Int16 value)
 659                 {
 660                         PollEvents rval;
 661                         if (ToPollEvents (value, out rval) == -1)
 662                                 ThrowArgumentException (value);
 663                         return rval;
 664                 }
 665
 666                 [DllImport (LIB, EntryPoint="Mono_Posix_FromXattrFlags")]
 667                 private static extern int FromXattrFlags (XattrFlags value, out Int32 rval);
 668
 669                 public static bool TryFromXattrFlags (XattrFlags value, out Int32 rval)
 670                 {
 671                         return FromXattrFlags (value, out rval) == 0;
 672                 }
 673
 674                 public static Int32 FromXattrFlags (XattrFlags value)
 675                 {
 676                         Int32 rval;
 677                         if (FromXattrFlags (value, out rval) == -1)
 678                                 ThrowArgumentException (value);
 679                         return rval;
 680                 }
 681
 682                 [DllImport (LIB, EntryPoint="Mono_Posix_ToXattrFlags")]
 683                 private static extern int ToXattrFlags (Int32 value, out XattrFlags rval);
 684
 685                 public static bool TryToXattrFlags (Int32 value, out XattrFlags rval)
 686                 {
 687                         return ToXattrFlags (value, out rval) == 0;
 688                 }
 689
 690                 public static XattrFlags ToXattrFlags (Int32 value)
 691                 {
 692                         XattrFlags rval;
 693                         if (ToXattrFlags (value, out rval) == -1)
 694                                 ThrowArgumentException (value);
 695                         return rval;
 696                 }
 697
 698                 //
 699                 // Non-generated exports
 700                 //
 701
 702                 // convert from octal representation.
 703                 public static FilePermissions ToFilePermissions (string value)
 704                 {
 705                         uint n = Convert.ToUInt32 (value, 8);
 706                         return ToFilePermissions (n);
 707                 }
 708
 709                 public static readonly DateTime LocalUnixEpoch =
 710                         new DateTime (1970, 1, 1).ToLocalTime();
 711
 712                 public static DateTime ToDateTime (long time)
 713                 {
 714                         return FromTimeT (time);
 715                 }
 716
 717                 public static long FromDateTime (DateTime time)
 718                 {
 719                         return ToTimeT (time);
 720                 }
 721
 722                 public static DateTime FromTimeT (long time)
 723                 {
 724                         DateTime r = LocalUnixEpoch.AddSeconds (time);
 725                         return r;
 726                 }
 727
 728                 public static long ToTimeT (DateTime time)
 729                 {
 730                         return (long) time.Subtract (LocalUnixEpoch).TotalSeconds;
 731                 }
 732
 733                 public static OpenFlags ToOpenFlags (FileMode mode, FileAccess access)
 734                 {
 735                         OpenFlags flags = 0;
 736                         switch (mode) {
 737                         case FileMode.CreateNew:
 738                                 flags = OpenFlags.O_CREAT | OpenFlags.O_EXCL;
 739                                 break;
 740                         case FileMode.Create:
 741                                 flags = OpenFlags.O_CREAT | OpenFlags.O_TRUNC;
 742                                 break;
 743                         case FileMode.Open:
 744                                 // do nothing
 745                                 break;
 746                         case FileMode.OpenOrCreate:
 747                                 flags = OpenFlags.O_CREAT;
 748                                 break;
 749                         case FileMode.Truncate:
 750                                 flags = OpenFlags.O_TRUNC;
 751                                 break;
 752                         case FileMode.Append:
 753                                 flags = OpenFlags.O_APPEND;
 754                                 break;
 755                         default:
 756                                 throw new ArgumentException (Locale.GetText ("Unsupported mode value"), "mode");
 757                         }
 758
 759                         // Is O_LARGEFILE supported?
 760                         int _v;
 761                         if (TryFromOpenFlags (OpenFlags.O_LARGEFILE, out _v))
 762                                 flags |= OpenFlags.O_LARGEFILE;
 763
 764                         switch (access) {
 765                         case FileAccess.Read:
 766                                 flags |= OpenFlags.O_RDONLY;
 767                                 break;
 768                         case FileAccess.Write:
 769                                 flags |= OpenFlags.O_WRONLY;
 770                                 break;
 771                         case FileAccess.ReadWrite:
 772                                 flags |= OpenFlags.O_RDWR;
 773                                 break;
 774                         default:
 775                                 throw new ArgumentOutOfRangeException (Locale.GetText ("Unsupported access value"), "access");
 776                         }
 777
 778                         return flags;
 779                 }
 780
 781                 public static string ToFopenMode (FileAccess access)
 782                 {
 783                         switch (access) {
 784                                 case FileAccess.Read:       return "rb";
 785                                 case FileAccess.Write:      return "wb";
 786                                 case FileAccess.ReadWrite:  return "r+b";
 787                                 default:                    throw new ArgumentOutOfRangeException ("access");
 788                         }
 789                 }
 790
 791                 public static string ToFopenMode (FileMode mode)
 792                 {
 793                         switch (mode) {
 794                                 case FileMode.CreateNew: case FileMode.Create:        return "w+b";
 795                                 case FileMode.Open:      case FileMode.OpenOrCreate:  return "r+b";
 796                                 case FileMode.Truncate: return "w+b";
 797                                 case FileMode.Append:   return "a+b";
 798                                 default:                throw new ArgumentOutOfRangeException ("mode");
 799                         }
 800                 }
 801
 802                 private static readonly string[][] fopen_modes = new string[][]{
 803                         //                                         Read                       Write ReadWrite
 804                         /*    FileMode.CreateNew: */  new string[]{"Can't Read+Create",       "wb", "w+b"},
 805                         /*       FileMode.Create: */  new string[]{"Can't Read+Create",       "wb", "w+b"},
 806                         /*         FileMode.Open: */  new string[]{"rb",                      "wb", "r+b"},
 807                         /* FileMode.OpenOrCreate: */  new string[]{"rb",                      "wb", "r+b"},
 808                         /*     FileMode.Truncate: */  new string[]{"Cannot Truncate and Read","wb", "w+b"},
 809                         /*       FileMode.Append: */  new string[]{"Cannot Append and Read",  "ab", "a+b"},
 810                 };
 811
 812                 public static string ToFopenMode (FileMode mode, FileAccess access)
 813                 {
 814                         int fm = -1, fa = -1;
 815                         switch (mode) {
 816                                 case FileMode.CreateNew:    fm = 0; break;
 817                                 case FileMode.Create:       fm = 1; break;
 818                                 case FileMode.Open:         fm = 2; break;
 819                                 case FileMode.OpenOrCreate: fm = 3; break;
 820                                 case FileMode.Truncate:     fm = 4; break;
 821                                 case FileMode.Append:       fm = 5; break;
 822                         }
 823                         switch (access) {
 824                                 case FileAccess.Read:       fa = 0; break;
 825                                 case FileAccess.Write:      fa = 1; break;
 826                                 case FileAccess.ReadWrite:  fa = 2; break;
 827                         }
 828
 829                         if (fm == -1)
 830                                 throw new ArgumentOutOfRangeException ("mode");
 831                         if (fa == -1)
 832                                 throw new ArgumentOutOfRangeException ("access");
 833
 834                         string fopen_mode = fopen_modes [fm][fa];
 835                         if (fopen_mode [0] != 'r' && fopen_mode [0] != 'w' && fopen_mode [0] != 'a')
 836                                 throw new ArgumentException (fopen_mode);
 837                         return fopen_mode;
 838                 }
 839         }
 840 }
 841
 842 // vim: noexpandtab