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_FromLockfCommand")]
 603                 private static extern int FromLockfCommand (LockfCommand value, out Int32 rval);
 604
 605                 public static bool TryFromLockfCommand (LockfCommand value, out Int32 rval)
 606                 {
 607                         return FromLockfCommand (value, out rval) == 0;
 608                 }
 609
 610                 public static Int32 FromLockfCommand (LockfCommand value)
 611                 {
 612                         Int32 rval;
 613                         if (FromLockfCommand (value, out rval) == -1)
 614                                 ThrowArgumentException (value);
 615                         return rval;
 616                 }
 617
 618                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockfCommand")]
 619                 private static extern int ToLockfCommand (Int32 value, out LockfCommand rval);
 620
 621                 public static bool TryToLockfCommand (Int32 value, out LockfCommand rval)
 622                 {
 623                         return ToLockfCommand (value, out rval) == 0;
 624                 }
 625
 626                 public static LockfCommand ToLockfCommand (Int32 value)
 627                 {
 628                         LockfCommand rval;
 629                         if (ToLockfCommand (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                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMountFlags")]
 699                 private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
 700
 701                 public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
 702                 {
 703                         return FromMountFlags (value, out rval) == 0;
 704                 }
 705
 706                 public static UInt64 FromMountFlags (MountFlags value)
 707                 {
 708                         UInt64 rval;
 709                         if (FromMountFlags (value, out rval) == -1)
 710                                 ThrowArgumentException (value);
 711                         return rval;
 712                 }
 713
 714                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMountFlags")]
 715                 private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
 716
 717                 public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
 718                 {
 719                         return ToMountFlags (value, out rval) == 0;
 720                 }
 721
 722                 public static MountFlags ToMountFlags (UInt64 value)
 723                 {
 724                         MountFlags rval;
 725                         if (ToMountFlags (value, out rval) == -1)
 726                                 ThrowArgumentException (value);
 727                         return rval;
 728                 }
 729
 730                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapFlags")]
 731                 private static extern int FromMmapFlags (MmapFlags value, out Int32 rval);
 732
 733                 public static bool TryFromMmapFlags (MmapFlags value, out Int32 rval)
 734                 {
 735                         return FromMmapFlags (value, out rval) == 0;
 736                 }
 737
 738                 public static Int32 FromMmapFlags (MmapFlags value)
 739                 {
 740                         Int32 rval;
 741                         if (FromMmapFlags (value, out rval) == -1)
 742                                 ThrowArgumentException (value);
 743                         return rval;
 744                 }
 745
 746                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapFlags")]
 747                 private static extern int ToMmapFlags (Int32 value, out MmapFlags rval);
 748
 749                 public static bool TryToMmapFlags (Int32 value, out MmapFlags rval)
 750                 {
 751                         return ToMmapFlags (value, out rval) == 0;
 752                 }
 753
 754                 public static MmapFlags ToMmapFlags (Int32 value)
 755                 {
 756                         MmapFlags rval;
 757                         if (ToMmapFlags (value, out rval) == -1)
 758                                 ThrowArgumentException (value);
 759                         return rval;
 760                 }
 761
 762                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMmapProt")]
 763                 private static extern int FromMmapProt (MmapProt value, out Int32 rval);
 764
 765                 public static bool TryFromMmapProt (MmapProt value, out Int32 rval)
 766                 {
 767                         return FromMmapProt (value, out rval) == 0;
 768                 }
 769
 770                 public static Int32 FromMmapProt (MmapProt value)
 771                 {
 772                         Int32 rval;
 773                         if (FromMmapProt (value, out rval) == -1)
 774                                 ThrowArgumentException (value);
 775                         return rval;
 776                 }
 777
 778                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMmapProt")]
 779                 private static extern int ToMmapProt (Int32 value, out MmapProt rval);
 780
 781                 public static bool TryToMmapProt (Int32 value, out MmapProt rval)
 782                 {
 783                         return ToMmapProt (value, out rval) == 0;
 784                 }
 785
 786                 public static MmapProt ToMmapProt (Int32 value)
 787                 {
 788                         MmapProt rval;
 789                         if (ToMmapProt (value, out rval) == -1)
 790                                 ThrowArgumentException (value);
 791                         return rval;
 792                 }
 793
 794                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMsyncFlags")]
 795                 private static extern int FromMsyncFlags (MsyncFlags value, out Int32 rval);
 796
 797                 public static bool TryFromMsyncFlags (MsyncFlags value, out Int32 rval)
 798                 {
 799                         return FromMsyncFlags (value, out rval) == 0;
 800                 }
 801
 802                 public static Int32 FromMsyncFlags (MsyncFlags value)
 803                 {
 804                         Int32 rval;
 805                         if (FromMsyncFlags (value, out rval) == -1)
 806                                 ThrowArgumentException (value);
 807                         return rval;
 808                 }
 809
 810                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMsyncFlags")]
 811                 private static extern int ToMsyncFlags (Int32 value, out MsyncFlags rval);
 812
 813                 public static bool TryToMsyncFlags (Int32 value, out MsyncFlags rval)
 814                 {
 815                         return ToMsyncFlags (value, out rval) == 0;
 816                 }
 817
 818                 public static MsyncFlags ToMsyncFlags (Int32 value)
 819                 {
 820                         MsyncFlags rval;
 821                         if (ToMsyncFlags (value, out rval) == -1)
 822                                 ThrowArgumentException (value);
 823                         return rval;
 824                 }
 825
 826                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMlockallFlags")]
 827                 private static extern int FromMlockallFlags (MlockallFlags value, out Int32 rval);
 828
 829                 public static bool TryFromMlockallFlags (MlockallFlags value, out Int32 rval)
 830                 {
 831                         return FromMlockallFlags (value, out rval) == 0;
 832                 }
 833
 834                 public static Int32 FromMlockallFlags (MlockallFlags value)
 835                 {
 836                         Int32 rval;
 837                         if (FromMlockallFlags (value, out rval) == -1)
 838                                 ThrowArgumentException (value);
 839                         return rval;
 840                 }
 841
 842                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMlockallFlags")]
 843                 private static extern int ToMlockallFlags (Int32 value, out MlockallFlags rval);
 844
 845                 public static bool TryToMlockallFlags (Int32 value, out MlockallFlags rval)
 846                 {
 847                         return ToMlockallFlags (value, out rval) == 0;
 848                 }
 849
 850                 public static MlockallFlags ToMlockallFlags (Int32 value)
 851                 {
 852                         MlockallFlags rval;
 853                         if (ToMlockallFlags (value, out rval) == -1)
 854                                 ThrowArgumentException (value);
 855                         return rval;
 856                 }
 857
 858                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMremapFlags")]
 859                 private static extern int FromMremapFlags (MremapFlags value, out UInt64 rval);
 860
 861                 public static bool TryFromMremapFlags (MremapFlags value, out UInt64 rval)
 862                 {
 863                         return FromMremapFlags (value, out rval) == 0;
 864                 }
 865
 866                 public static UInt64 FromMremapFlags (MremapFlags value)
 867                 {
 868                         UInt64 rval;
 869                         if (FromMremapFlags (value, out rval) == -1)
 870                                 ThrowArgumentException (value);
 871                         return rval;
 872                 }
 873
 874                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMremapFlags")]
 875                 private static extern int ToMremapFlags (UInt64 value, out MremapFlags rval);
 876
 877                 public static bool TryToMremapFlags (UInt64 value, out MremapFlags rval)
 878                 {
 879                         return ToMremapFlags (value, out rval) == 0;
 880                 }
 881
 882                 public static MremapFlags ToMremapFlags (UInt64 value)
 883                 {
 884                         MremapFlags rval;
 885                         if (ToMremapFlags (value, out rval) == -1)
 886                                 ThrowArgumentException (value);
 887                         return rval;
 888                 }
 889
 890                 //
 891                 // Non-generated exports
 892                 //
 893
 894                 // convert from octal representation.
 895                 public static FilePermissions FromOctalPermissionString (string value)
 896                 {
 897                         uint n = Convert.ToUInt32 (value, 8);
 898                         return ToFilePermissions (n);
 899                 }
 900
 901                 public static string ToOctalPermissionString (FilePermissions value)
 902                 {
 903                         string s = Convert.ToString ((int) (value & ~FilePermissions.S_IFMT), 8);
 904                         return new string ('0', 4-s.Length) + s;
 905                 }
 906
 907                 public static FilePermissions FromUnixPermissionString (string value)
 908                 {
 909                         if (value == null)
 910                                 throw new ArgumentNullException ("value");
 911                         if (value.Length != 9 && value.Length != 10)
 912                                 throw new ArgumentException ("value", "must contain 9 or 10 characters");
 913
 914                         int i = 0;
 915                         FilePermissions perms = new FilePermissions ();
 916
 917                         if (value.Length == 10) {
 918                                 perms |= GetUnixPermissionDevice (value [i]);
 919                                 ++i;
 920                         }
 921
 922                         perms |= GetUnixPermissionGroup (
 923                                 value [i++], FilePermissions.S_IRUSR,
 924                                 value [i++], FilePermissions.S_IWUSR,
 925                                 value [i++], FilePermissions.S_IXUSR,
 926                                 's', 'S', FilePermissions.S_ISUID);
 927
 928                         perms |= GetUnixPermissionGroup (
 929                                 value [i++], FilePermissions.S_IRGRP,
 930                                 value [i++], FilePermissions.S_IWGRP,
 931                                 value [i++], FilePermissions.S_IXGRP,
 932                                 's', 'S', FilePermissions.S_ISGID);
 933
 934                         perms |= GetUnixPermissionGroup (
 935                                 value [i++], FilePermissions.S_IROTH,
 936                                 value [i++], FilePermissions.S_IWOTH,
 937                                 value [i++], FilePermissions.S_IXOTH,
 938                                 't', 'T', FilePermissions.S_ISVTX);
 939
 940                         return perms;
 941                 }
 942
 943                 private static FilePermissions GetUnixPermissionDevice (char value)
 944                 {
 945                         switch (value) {
 946                         case 'd': return FilePermissions.S_IFDIR;
 947                         case 'c': return FilePermissions.S_IFCHR;
 948                         case 'b': return FilePermissions.S_IFBLK;
 949                         case '-': return FilePermissions.S_IFREG;
 950                         case 'p': return FilePermissions.S_IFIFO;
 951                         case 'l': return FilePermissions.S_IFLNK;
 952                         case 's': return FilePermissions.S_IFSOCK;
 953                         }
 954                         throw new ArgumentException ("value", "invalid device specification: " +
 955                                 value);
 956                 }
 957
 958                 private static FilePermissions GetUnixPermissionGroup (
 959                         char read, FilePermissions readb,
 960                         char write, FilePermissions writeb,
 961                         char exec, FilePermissions execb,
 962                         char xboth, char xbitonly, FilePermissions xbit)
 963                 {
 964                         FilePermissions perms = new FilePermissions ();
 965                         if (read == 'r')
 966                                 perms |= readb;
 967                         if (write == 'w')
 968                                 perms |= writeb;
 969                         if (exec == 'x')
 970                                 perms |= execb;
 971                         else if (exec == xbitonly)
 972                                 perms |= xbit;
 973                         else if (exec == xboth)
 974                                 perms |= (execb | xbit);
 975                         return perms;
 976                 }
 977
 978                 // Create ls(1) drwxrwxrwx permissions display
 979                 public static string ToUnixPermissionString (FilePermissions value)
 980                 {
 981                         char [] access = new char[] {
 982                                 '-',            // device
 983                                 '-', '-', '-',  // owner
 984                                 '-', '-', '-',  // group
 985                                 '-', '-', '-',  // other
 986                         };
 987                         bool have_device = true;
 988                         switch (value & FilePermissions.S_IFMT) {
 989                                 case FilePermissions.S_IFDIR:   access [0] = 'd'; break;
 990                                 case FilePermissions.S_IFCHR:   access [0] = 'c'; break;
 991                                 case FilePermissions.S_IFBLK:   access [0] = 'b'; break;
 992                                 case FilePermissions.S_IFREG:   access [0] = '-'; break;
 993                                 case FilePermissions.S_IFIFO:   access [0] = 'p'; break;
 994                                 case FilePermissions.S_IFLNK:   access [0] = 'l'; break;
 995                                 case FilePermissions.S_IFSOCK:  access [0] = 's'; break;
 996                                 default:                        have_device = false; break;
 997                         }
 998                         SetUnixPermissionGroup (value, access, 1,
 999                                 FilePermissions.S_IRUSR, FilePermissions.S_IWUSR, FilePermissions.S_IXUSR,
1000                                 's', 'S', FilePermissions.S_ISUID);
1001                         SetUnixPermissionGroup (value, access, 4,
1002                                 FilePermissions.S_IRGRP, FilePermissions.S_IWGRP, FilePermissions.S_IXGRP,
1003                                 's', 'S', FilePermissions.S_ISGID);
1004                         SetUnixPermissionGroup (value, access, 7,
1005                                 FilePermissions.S_IROTH, FilePermissions.S_IWOTH, FilePermissions.S_IXOTH,
1006                                 't', 'T', FilePermissions.S_ISVTX);
1007                         return have_device
1008                                 ? new string (access)
1009                                 : new string (access, 1, 9);
1010                 }
1011
1012                 private static void SetUnixPermissionGroup (FilePermissions value,
1013                         char[] access, int index,
1014                         FilePermissions read, FilePermissions write, FilePermissions exec,
1015                         char both, char setonly, FilePermissions setxbit)
1016                 {
1017                         if (UnixFileSystemInfo.IsType (value, read))
1018                                 access [index] = 'r';
1019                         if (UnixFileSystemInfo.IsType (value, write))
1020                                 access [index+1] = 'w';
1021                         access [index+2] = GetSymbolicMode (value, exec, both, setonly, setxbit);
1022                 }
1023
1024                 // Implement the GNU ls(1) permissions spec; see `info coreutils ls`,
1025                 // section 10.1.2, the `-l' argument information.
1026                 private static char GetSymbolicMode (FilePermissions value,
1027                         FilePermissions xbit, char both, char setonly, FilePermissions setxbit)
1028                 {
1029                         bool is_x  = UnixFileSystemInfo.IsType (value, xbit);
1030                         bool is_sx = UnixFileSystemInfo.IsType (value, setxbit);
1031
1032                         if (is_x && is_sx)
1033                                 return both;
1034                         if (is_sx)
1035                                 return setonly;
1036                         if (is_x)
1037                                 return 'x';
1038                         return '-';
1039                 }
1040
1041                 public static readonly DateTime LocalUnixEpoch =
1042                         new DateTime (1970, 1, 1).ToLocalTime();
1043
1044                 public static DateTime ToDateTime (long time)
1045                 {
1046                         return FromTimeT (time);
1047                 }
1048
1049                 public static long FromDateTime (DateTime time)
1050                 {
1051                         return ToTimeT (time);
1052                 }
1053
1054                 public static DateTime FromTimeT (long time)
1055                 {
1056                         DateTime r = LocalUnixEpoch.AddSeconds (time);
1057                         return r;
1058                 }
1059
1060                 public static long ToTimeT (DateTime time)
1061                 {
1062                         return (long) time.Subtract (LocalUnixEpoch).TotalSeconds;
1063                 }
1064
1065                 public static OpenFlags ToOpenFlags (FileMode mode, FileAccess access)
1066                 {
1067                         OpenFlags flags = 0;
1068                         switch (mode) {
1069                         case FileMode.CreateNew:
1070                                 flags = OpenFlags.O_CREAT | OpenFlags.O_EXCL;
1071                                 break;
1072                         case FileMode.Create:
1073                                 flags = OpenFlags.O_CREAT | OpenFlags.O_TRUNC;
1074                                 break;
1075                         case FileMode.Open:
1076                                 // do nothing
1077                                 break;
1078                         case FileMode.OpenOrCreate:
1079                                 flags = OpenFlags.O_CREAT;
1080                                 break;
1081                         case FileMode.Truncate:
1082                                 flags = OpenFlags.O_TRUNC;
1083                                 break;
1084                         case FileMode.Append:
1085                                 flags = OpenFlags.O_APPEND;
1086                                 break;
1087                         default:
1088                                 throw new ArgumentException (Locale.GetText ("Unsupported mode value"), "mode");
1089                         }
1090
1091                         // Is O_LARGEFILE supported?
1092                         int _v;
1093                         if (TryFromOpenFlags (OpenFlags.O_LARGEFILE, out _v))
1094                                 flags |= OpenFlags.O_LARGEFILE;
1095
1096                         switch (access) {
1097                         case FileAccess.Read:
1098                                 flags |= OpenFlags.O_RDONLY;
1099                                 break;
1100                         case FileAccess.Write:
1101                                 flags |= OpenFlags.O_WRONLY;
1102                                 break;
1103                         case FileAccess.ReadWrite:
1104                                 flags |= OpenFlags.O_RDWR;
1105                                 break;
1106                         default:
1107                                 throw new ArgumentOutOfRangeException (Locale.GetText ("Unsupported access value"), "access");
1108                         }
1109
1110                         return flags;
1111                 }
1112
1113                 public static string ToFopenMode (FileAccess access)
1114                 {
1115                         switch (access) {
1116                                 case FileAccess.Read:       return "rb";
1117                                 case FileAccess.Write:      return "wb";
1118                                 case FileAccess.ReadWrite:  return "r+b";
1119                                 default:                    throw new ArgumentOutOfRangeException ("access");
1120                         }
1121                 }
1122
1123                 public static string ToFopenMode (FileMode mode)
1124                 {
1125                         switch (mode) {
1126                                 case FileMode.CreateNew: case FileMode.Create:        return "w+b";
1127                                 case FileMode.Open:      case FileMode.OpenOrCreate:  return "r+b";
1128                                 case FileMode.Truncate: return "w+b";
1129                                 case FileMode.Append:   return "a+b";
1130                                 default:                throw new ArgumentOutOfRangeException ("mode");
1131                         }
1132                 }
1133
1134                 private static readonly string[][] fopen_modes = new string[][]{
1135                         //                                         Read                       Write ReadWrite
1136                         /*    FileMode.CreateNew: */  new string[]{"Can't Read+Create",       "wb", "w+b"},
1137                         /*       FileMode.Create: */  new string[]{"Can't Read+Create",       "wb", "w+b"},
1138                         /*         FileMode.Open: */  new string[]{"rb",                      "wb", "r+b"},
1139                         /* FileMode.OpenOrCreate: */  new string[]{"rb",                      "wb", "r+b"},
1140                         /*     FileMode.Truncate: */  new string[]{"Cannot Truncate and Read","wb", "w+b"},
1141                         /*       FileMode.Append: */  new string[]{"Cannot Append and Read",  "ab", "a+b"},
1142                 };
1143
1144                 public static string ToFopenMode (FileMode mode, FileAccess access)
1145                 {
1146                         int fm = -1, fa = -1;
1147                         switch (mode) {
1148                                 case FileMode.CreateNew:    fm = 0; break;
1149                                 case FileMode.Create:       fm = 1; break;
1150                                 case FileMode.Open:         fm = 2; break;
1151                                 case FileMode.OpenOrCreate: fm = 3; break;
1152                                 case FileMode.Truncate:     fm = 4; break;
1153                                 case FileMode.Append:       fm = 5; break;
1154                         }
1155                         switch (access) {
1156                                 case FileAccess.Read:       fa = 0; break;
1157                                 case FileAccess.Write:      fa = 1; break;
1158                                 case FileAccess.ReadWrite:  fa = 2; break;
1159                         }
1160
1161                         if (fm == -1)
1162                                 throw new ArgumentOutOfRangeException ("mode");
1163                         if (fa == -1)
1164                                 throw new ArgumentOutOfRangeException ("access");
1165
1166                         string fopen_mode = fopen_modes [fm][fa];
1167                         if (fopen_mode [0] != 'r' && fopen_mode [0] != 'w' && fopen_mode [0] != 'a')
1168                                 throw new ArgumentException (fopen_mode);
1169                         return fopen_mode;
1170                 }
1171         }
1172 }
1173
1174 // vim: noexpandtab