mcs/class/Mono.Posix/Mono.Posix/PosixConvert.cs

   1 /*
   2  * This file was automatically generated by make-map from Mono.Posix.dll.
   3  *
   4  * DO NOT MODIFY.
   5  */
   6
   7 using System;
   8 using System.Runtime.InteropServices;
   9 using Mono.Posix;
  10
  11 namespace Mono.Posix {
  12
  13         public sealed /* static */ class PosixConvert
  14         {
  15                 private PosixConvert () {}
  16
  17                 private const string LIB = "MonoPosixHelper";
  18
  19                 private static void ThrowArgumentException (object value)
  20                 {
  21                         throw new ArgumentOutOfRangeException ("value", value,
  22                                 Locale.GetText ("Current platform doesn't support this value."));
  23                 }
  24
  25                 [DllImport (LIB, EntryPoint="Mono_Posix_FromError")]
  26                 private static extern int FromError (Error value, out Int32 rval);
  27
  28                 public static bool TryFromError (Error value, out Int32 rval)
  29                 {
  30                         return FromError (value, out rval) == 0;
  31                 }
  32
  33                 public static Int32 FromError (Error value)
  34                 {
  35                         Int32 rval;
  36                         if (FromError (value, out rval) == -1)
  37                                 ThrowArgumentException (value);
  38                         return rval;
  39                 }
  40
  41                 [DllImport (LIB, EntryPoint="Mono_Posix_ToError")]
  42                 private static extern int ToError (Int32 value, out Error rval);
  43
  44                 public static bool TryToError (Int32 value, out Error rval)
  45                 {
  46                         return ToError (value, out rval) == 0;
  47                 }
  48
  49                 public static Error ToError (Int32 value)
  50                 {
  51                         Error rval;
  52                         if (ToError (value, out rval) == -1)
  53                                 ThrowArgumentException (value);
  54                         return rval;
  55                 }
  56
  57                 [DllImport (LIB, EntryPoint="Mono_Posix_FromOpenFlags")]
  58                 private static extern int FromOpenFlags (OpenFlags value, out Int32 rval);
  59
  60                 public static bool TryFromOpenFlags (OpenFlags value, out Int32 rval)
  61                 {
  62                         return FromOpenFlags (value, out rval) == 0;
  63                 }
  64
  65                 public static Int32 FromOpenFlags (OpenFlags value)
  66                 {
  67                         Int32 rval;
  68                         if (FromOpenFlags (value, out rval) == -1)
  69                                 ThrowArgumentException (value);
  70                         return rval;
  71                 }
  72
  73                 [DllImport (LIB, EntryPoint="Mono_Posix_ToOpenFlags")]
  74                 private static extern int ToOpenFlags (Int32 value, out OpenFlags rval);
  75
  76                 public static bool TryToOpenFlags (Int32 value, out OpenFlags rval)
  77                 {
  78                         return ToOpenFlags (value, out rval) == 0;
  79                 }
  80
  81                 public static OpenFlags ToOpenFlags (Int32 value)
  82                 {
  83                         OpenFlags rval;
  84                         if (ToOpenFlags (value, out rval) == -1)
  85                                 ThrowArgumentException (value);
  86                         return rval;
  87                 }
  88
  89                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFilePermissions")]
  90                 private static extern int FromFilePermissions (FilePermissions value, out UInt32 rval);
  91
  92                 public static bool TryFromFilePermissions (FilePermissions value, out UInt32 rval)
  93                 {
  94                         return FromFilePermissions (value, out rval) == 0;
  95                 }
  96
  97                 public static UInt32 FromFilePermissions (FilePermissions value)
  98                 {
  99                         UInt32 rval;
 100                         if (FromFilePermissions (value, out rval) == -1)
 101                                 ThrowArgumentException (value);
 102                         return rval;
 103                 }
 104
 105                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFilePermissions")]
 106                 private static extern int ToFilePermissions (UInt32 value, out FilePermissions rval);
 107
 108                 public static bool TryToFilePermissions (UInt32 value, out FilePermissions rval)
 109                 {
 110                         return ToFilePermissions (value, out rval) == 0;
 111                 }
 112
 113                 public static FilePermissions ToFilePermissions (UInt32 value)
 114                 {
 115                         FilePermissions rval;
 116                         if (ToFilePermissions (value, out rval) == -1)
 117                                 ThrowArgumentException (value);
 118                         return rval;
 119                 }
 120
 121                 [DllImport (LIB, EntryPoint="Mono_Posix_FromFcntlCommand")]
 122                 private static extern int FromFcntlCommand (FcntlCommand value, out Int32 rval);
 123
 124                 public static bool TryFromFcntlCommand (FcntlCommand value, out Int32 rval)
 125                 {
 126                         return FromFcntlCommand (value, out rval) == 0;
 127                 }
 128
 129                 public static Int32 FromFcntlCommand (FcntlCommand value)
 130                 {
 131                         Int32 rval;
 132                         if (FromFcntlCommand (value, out rval) == -1)
 133                                 ThrowArgumentException (value);
 134                         return rval;
 135                 }
 136
 137                 [DllImport (LIB, EntryPoint="Mono_Posix_ToFcntlCommand")]
 138                 private static extern int ToFcntlCommand (Int32 value, out FcntlCommand rval);
 139
 140                 public static bool TryToFcntlCommand (Int32 value, out FcntlCommand rval)
 141                 {
 142                         return ToFcntlCommand (value, out rval) == 0;
 143                 }
 144
 145                 public static FcntlCommand ToFcntlCommand (Int32 value)
 146                 {
 147                         FcntlCommand rval;
 148                         if (ToFcntlCommand (value, out rval) == -1)
 149                                 ThrowArgumentException (value);
 150                         return rval;
 151                 }
 152
 153                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 154                 private static extern int FromLockType (LockType value, out Int16 rval);
 155
 156                 public static bool TryFromLockType (LockType value, out Int16 rval)
 157                 {
 158                         return FromLockType (value, out rval) == 0;
 159                 }
 160
 161                 public static Int16 FromLockType (LockType value)
 162                 {
 163                         Int16 rval;
 164                         if (FromLockType (value, out rval) == -1)
 165                                 ThrowArgumentException (value);
 166                         return rval;
 167                 }
 168
 169                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockType")]
 170                 private static extern int ToLockType (Int16 value, out LockType rval);
 171
 172                 public static bool TryToLockType (Int16 value, out LockType rval)
 173                 {
 174                         return ToLockType (value, out rval) == 0;
 175                 }
 176
 177                 public static LockType ToLockType (Int16 value)
 178                 {
 179                         LockType rval;
 180                         if (ToLockType (value, out rval) == -1)
 181                                 ThrowArgumentException (value);
 182                         return rval;
 183                 }
 184
 185                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSeekFlags")]
 186                 private static extern int FromSeekFlags (SeekFlags value, out Int16 rval);
 187
 188                 public static bool TryFromSeekFlags (SeekFlags value, out Int16 rval)
 189                 {
 190                         return FromSeekFlags (value, out rval) == 0;
 191                 }
 192
 193                 public static Int16 FromSeekFlags (SeekFlags value)
 194                 {
 195                         Int16 rval;
 196                         if (FromSeekFlags (value, out rval) == -1)
 197                                 ThrowArgumentException (value);
 198                         return rval;
 199                 }
 200
 201                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSeekFlags")]
 202                 private static extern int ToSeekFlags (Int16 value, out SeekFlags rval);
 203
 204                 public static bool TryToSeekFlags (Int16 value, out SeekFlags rval)
 205                 {
 206                         return ToSeekFlags (value, out rval) == 0;
 207                 }
 208
 209                 public static SeekFlags ToSeekFlags (Int16 value)
 210                 {
 211                         SeekFlags rval;
 212                         if (ToSeekFlags (value, out rval) == -1)
 213                                 ThrowArgumentException (value);
 214                         return rval;
 215                 }
 216
 217                 [DllImport (LIB, EntryPoint="Mono_Posix_FromDirectoryNotifyFlags")]
 218                 private static extern int FromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval);
 219
 220                 public static bool TryFromDirectoryNotifyFlags (DirectoryNotifyFlags value, out Int32 rval)
 221                 {
 222                         return FromDirectoryNotifyFlags (value, out rval) == 0;
 223                 }
 224
 225                 public static Int32 FromDirectoryNotifyFlags (DirectoryNotifyFlags value)
 226                 {
 227                         Int32 rval;
 228                         if (FromDirectoryNotifyFlags (value, out rval) == -1)
 229                                 ThrowArgumentException (value);
 230                         return rval;
 231                 }
 232
 233                 [DllImport (LIB, EntryPoint="Mono_Posix_ToDirectoryNotifyFlags")]
 234                 private static extern int ToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval);
 235
 236                 public static bool TryToDirectoryNotifyFlags (Int32 value, out DirectoryNotifyFlags rval)
 237                 {
 238                         return ToDirectoryNotifyFlags (value, out rval) == 0;
 239                 }
 240
 241                 public static DirectoryNotifyFlags ToDirectoryNotifyFlags (Int32 value)
 242                 {
 243                         DirectoryNotifyFlags rval;
 244                         if (ToDirectoryNotifyFlags (value, out rval) == -1)
 245                                 ThrowArgumentException (value);
 246                         return rval;
 247                 }
 248
 249                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixFadviseAdvice")]
 250                 private static extern int FromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval);
 251
 252                 public static bool TryFromPosixFadviseAdvice (PosixFadviseAdvice value, out Int32 rval)
 253                 {
 254                         return FromPosixFadviseAdvice (value, out rval) == 0;
 255                 }
 256
 257                 public static Int32 FromPosixFadviseAdvice (PosixFadviseAdvice value)
 258                 {
 259                         Int32 rval;
 260                         if (FromPosixFadviseAdvice (value, out rval) == -1)
 261                                 ThrowArgumentException (value);
 262                         return rval;
 263                 }
 264
 265                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixFadviseAdvice")]
 266                 private static extern int ToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval);
 267
 268                 public static bool TryToPosixFadviseAdvice (Int32 value, out PosixFadviseAdvice rval)
 269                 {
 270                         return ToPosixFadviseAdvice (value, out rval) == 0;
 271                 }
 272
 273                 public static PosixFadviseAdvice ToPosixFadviseAdvice (Int32 value)
 274                 {
 275                         PosixFadviseAdvice rval;
 276                         if (ToPosixFadviseAdvice (value, out rval) == -1)
 277                                 ThrowArgumentException (value);
 278                         return rval;
 279                 }
 280
 281                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPosixMadviseAdvice")]
 282                 private static extern int FromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval);
 283
 284                 public static bool TryFromPosixMadviseAdvice (PosixMadviseAdvice value, out Int32 rval)
 285                 {
 286                         return FromPosixMadviseAdvice (value, out rval) == 0;
 287                 }
 288
 289                 public static Int32 FromPosixMadviseAdvice (PosixMadviseAdvice value)
 290                 {
 291                         Int32 rval;
 292                         if (FromPosixMadviseAdvice (value, out rval) == -1)
 293                                 ThrowArgumentException (value);
 294                         return rval;
 295                 }
 296
 297                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPosixMadviseAdvice")]
 298                 private static extern int ToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval);
 299
 300                 public static bool TryToPosixMadviseAdvice (Int32 value, out PosixMadviseAdvice rval)
 301                 {
 302                         return ToPosixMadviseAdvice (value, out rval) == 0;
 303                 }
 304
 305                 public static PosixMadviseAdvice ToPosixMadviseAdvice (Int32 value)
 306                 {
 307                         PosixMadviseAdvice rval;
 308                         if (ToPosixMadviseAdvice (value, out rval) == -1)
 309                                 ThrowArgumentException (value);
 310                         return rval;
 311                 }
 312
 313                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSignum")]
 314                 private static extern int FromSignum (Signum value, out Int32 rval);
 315
 316                 public static bool TryFromSignum (Signum value, out Int32 rval)
 317                 {
 318                         return FromSignum (value, out rval) == 0;
 319                 }
 320
 321                 public static Int32 FromSignum (Signum value)
 322                 {
 323                         Int32 rval;
 324                         if (FromSignum (value, out rval) == -1)
 325                                 ThrowArgumentException (value);
 326                         return rval;
 327                 }
 328
 329                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSignum")]
 330                 private static extern int ToSignum (Int32 value, out Signum rval);
 331
 332                 public static bool TryToSignum (Int32 value, out Signum rval)
 333                 {
 334                         return ToSignum (value, out rval) == 0;
 335                 }
 336
 337                 public static Signum ToSignum (Int32 value)
 338                 {
 339                         Signum rval;
 340                         if (ToSignum (value, out rval) == -1)
 341                                 ThrowArgumentException (value);
 342                         return rval;
 343                 }
 344
 345                 [DllImport (LIB, EntryPoint="Mono_Posix_FromMountFlags")]
 346                 private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
 347
 348                 public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
 349                 {
 350                         return FromMountFlags (value, out rval) == 0;
 351                 }
 352
 353                 public static UInt64 FromMountFlags (MountFlags value)
 354                 {
 355                         UInt64 rval;
 356                         if (FromMountFlags (value, out rval) == -1)
 357                                 ThrowArgumentException (value);
 358                         return rval;
 359                 }
 360
 361                 [DllImport (LIB, EntryPoint="Mono_Posix_ToMountFlags")]
 362                 private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
 363
 364                 public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
 365                 {
 366                         return ToMountFlags (value, out rval) == 0;
 367                 }
 368
 369                 public static MountFlags ToMountFlags (UInt64 value)
 370                 {
 371                         MountFlags rval;
 372                         if (ToMountFlags (value, out rval) == -1)
 373                                 ThrowArgumentException (value);
 374                         return rval;
 375                 }
 376
 377                 [DllImport (LIB, EntryPoint="Mono_Posix_FromUmountFlags")]
 378                 private static extern int FromUmountFlags (UmountFlags value, out Int32 rval);
 379
 380                 public static bool TryFromUmountFlags (UmountFlags value, out Int32 rval)
 381                 {
 382                         return FromUmountFlags (value, out rval) == 0;
 383                 }
 384
 385                 public static Int32 FromUmountFlags (UmountFlags value)
 386                 {
 387                         Int32 rval;
 388                         if (FromUmountFlags (value, out rval) == -1)
 389                                 ThrowArgumentException (value);
 390                         return rval;
 391                 }
 392
 393                 [DllImport (LIB, EntryPoint="Mono_Posix_ToUmountFlags")]
 394                 private static extern int ToUmountFlags (Int32 value, out UmountFlags rval);
 395
 396                 public static bool TryToUmountFlags (Int32 value, out UmountFlags rval)
 397                 {
 398                         return ToUmountFlags (value, out rval) == 0;
 399                 }
 400
 401                 public static UmountFlags ToUmountFlags (Int32 value)
 402                 {
 403                         UmountFlags rval;
 404                         if (ToUmountFlags (value, out rval) == -1)
 405                                 ThrowArgumentException (value);
 406                         return rval;
 407                 }
 408
 409                 [DllImport (LIB, EntryPoint="Mono_Posix_FromWaitOptions")]
 410                 private static extern int FromWaitOptions (WaitOptions value, out Int32 rval);
 411
 412                 public static bool TryFromWaitOptions (WaitOptions value, out Int32 rval)
 413                 {
 414                         return FromWaitOptions (value, out rval) == 0;
 415                 }
 416
 417                 public static Int32 FromWaitOptions (WaitOptions value)
 418                 {
 419                         Int32 rval;
 420                         if (FromWaitOptions (value, out rval) == -1)
 421                                 ThrowArgumentException (value);
 422                         return rval;
 423                 }
 424
 425                 [DllImport (LIB, EntryPoint="Mono_Posix_ToWaitOptions")]
 426                 private static extern int ToWaitOptions (Int32 value, out WaitOptions rval);
 427
 428                 public static bool TryToWaitOptions (Int32 value, out WaitOptions rval)
 429                 {
 430                         return ToWaitOptions (value, out rval) == 0;
 431                 }
 432
 433                 public static WaitOptions ToWaitOptions (Int32 value)
 434                 {
 435                         WaitOptions rval;
 436                         if (ToWaitOptions (value, out rval) == -1)
 437                                 ThrowArgumentException (value);
 438                         return rval;
 439                 }
 440
 441                 [DllImport (LIB, EntryPoint="Mono_Posix_FromAccessMode")]
 442                 private static extern int FromAccessMode (AccessMode value, out Int32 rval);
 443
 444                 public static bool TryFromAccessMode (AccessMode value, out Int32 rval)
 445                 {
 446                         return FromAccessMode (value, out rval) == 0;
 447                 }
 448
 449                 public static Int32 FromAccessMode (AccessMode value)
 450                 {
 451                         Int32 rval;
 452                         if (FromAccessMode (value, out rval) == -1)
 453                                 ThrowArgumentException (value);
 454                         return rval;
 455                 }
 456
 457                 [DllImport (LIB, EntryPoint="Mono_Posix_ToAccessMode")]
 458                 private static extern int ToAccessMode (Int32 value, out AccessMode rval);
 459
 460                 public static bool TryToAccessMode (Int32 value, out AccessMode rval)
 461                 {
 462                         return ToAccessMode (value, out rval) == 0;
 463                 }
 464
 465                 public static AccessMode ToAccessMode (Int32 value)
 466                 {
 467                         AccessMode rval;
 468                         if (ToAccessMode (value, out rval) == -1)
 469                                 ThrowArgumentException (value);
 470                         return rval;
 471                 }
 472
 473                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPathConf")]
 474                 private static extern int FromPathConf (PathConf value, out Int32 rval);
 475
 476                 public static bool TryFromPathConf (PathConf value, out Int32 rval)
 477                 {
 478                         return FromPathConf (value, out rval) == 0;
 479                 }
 480
 481                 public static Int32 FromPathConf (PathConf value)
 482                 {
 483                         Int32 rval;
 484                         if (FromPathConf (value, out rval) == -1)
 485                                 ThrowArgumentException (value);
 486                         return rval;
 487                 }
 488
 489                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPathConf")]
 490                 private static extern int ToPathConf (Int32 value, out PathConf rval);
 491
 492                 public static bool TryToPathConf (Int32 value, out PathConf rval)
 493                 {
 494                         return ToPathConf (value, out rval) == 0;
 495                 }
 496
 497                 public static PathConf ToPathConf (Int32 value)
 498                 {
 499                         PathConf rval;
 500                         if (ToPathConf (value, out rval) == -1)
 501                                 ThrowArgumentException (value);
 502                         return rval;
 503                 }
 504
 505                 [DllImport (LIB, EntryPoint="Mono_Posix_FromSysConf")]
 506                 private static extern int FromSysConf (SysConf value, out Int32 rval);
 507
 508                 public static bool TryFromSysConf (SysConf value, out Int32 rval)
 509                 {
 510                         return FromSysConf (value, out rval) == 0;
 511                 }
 512
 513                 public static Int32 FromSysConf (SysConf value)
 514                 {
 515                         Int32 rval;
 516                         if (FromSysConf (value, out rval) == -1)
 517                                 ThrowArgumentException (value);
 518                         return rval;
 519                 }
 520
 521                 [DllImport (LIB, EntryPoint="Mono_Posix_ToSysConf")]
 522                 private static extern int ToSysConf (Int32 value, out SysConf rval);
 523
 524                 public static bool TryToSysConf (Int32 value, out SysConf rval)
 525                 {
 526                         return ToSysConf (value, out rval) == 0;
 527                 }
 528
 529                 public static SysConf ToSysConf (Int32 value)
 530                 {
 531                         SysConf rval;
 532                         if (ToSysConf (value, out rval) == -1)
 533                                 ThrowArgumentException (value);
 534                         return rval;
 535                 }
 536
 537                 [DllImport (LIB, EntryPoint="Mono_Posix_FromConfStr")]
 538                 private static extern int FromConfStr (ConfStr value, out Int32 rval);
 539
 540                 public static bool TryFromConfStr (ConfStr value, out Int32 rval)
 541                 {
 542                         return FromConfStr (value, out rval) == 0;
 543                 }
 544
 545                 public static Int32 FromConfStr (ConfStr value)
 546                 {
 547                         Int32 rval;
 548                         if (FromConfStr (value, out rval) == -1)
 549                                 ThrowArgumentException (value);
 550                         return rval;
 551                 }
 552
 553                 [DllImport (LIB, EntryPoint="Mono_Posix_ToConfStr")]
 554                 private static extern int ToConfStr (Int32 value, out ConfStr rval);
 555
 556                 public static bool TryToConfStr (Int32 value, out ConfStr rval)
 557                 {
 558                         return ToConfStr (value, out rval) == 0;
 559                 }
 560
 561                 public static ConfStr ToConfStr (Int32 value)
 562                 {
 563                         ConfStr rval;
 564                         if (ToConfStr (value, out rval) == -1)
 565                                 ThrowArgumentException (value);
 566                         return rval;
 567                 }
 568
 569                 [DllImport (LIB, EntryPoint="Mono_Posix_FromLockFlags")]
 570                 private static extern int FromLockFlags (LockFlags value, out Int32 rval);
 571
 572                 public static bool TryFromLockFlags (LockFlags value, out Int32 rval)
 573                 {
 574                         return FromLockFlags (value, out rval) == 0;
 575                 }
 576
 577                 public static Int32 FromLockFlags (LockFlags value)
 578                 {
 579                         Int32 rval;
 580                         if (FromLockFlags (value, out rval) == -1)
 581                                 ThrowArgumentException (value);
 582                         return rval;
 583                 }
 584
 585                 [DllImport (LIB, EntryPoint="Mono_Posix_ToLockFlags")]
 586                 private static extern int ToLockFlags (Int32 value, out LockFlags rval);
 587
 588                 public static bool TryToLockFlags (Int32 value, out LockFlags rval)
 589                 {
 590                         return ToLockFlags (value, out rval) == 0;
 591                 }
 592
 593                 public static LockFlags ToLockFlags (Int32 value)
 594                 {
 595                         LockFlags rval;
 596                         if (ToLockFlags (value, out rval) == -1)
 597                                 ThrowArgumentException (value);
 598                         return rval;
 599                 }
 600
 601                 [DllImport (LIB, EntryPoint="Mono_Posix_FromPollEvents")]
 602                 private static extern int FromPollEvents (PollEvents value, out Int16 rval);
 603
 604                 public static bool TryFromPollEvents (PollEvents value, out Int16 rval)
 605                 {
 606                         return FromPollEvents (value, out rval) == 0;
 607                 }
 608
 609                 public static Int16 FromPollEvents (PollEvents value)
 610                 {
 611                         Int16 rval;
 612                         if (FromPollEvents (value, out rval) == -1)
 613                                 ThrowArgumentException (value);
 614                         return rval;
 615                 }
 616
 617                 [DllImport (LIB, EntryPoint="Mono_Posix_ToPollEvents")]
 618                 private static extern int ToPollEvents (Int16 value, out PollEvents rval);
 619
 620                 public static bool TryToPollEvents (Int16 value, out PollEvents rval)
 621                 {
 622                         return ToPollEvents (value, out rval) == 0;
 623                 }
 624
 625                 public static PollEvents ToPollEvents (Int16 value)
 626                 {
 627                         PollEvents rval;
 628                         if (ToPollEvents (value, out rval) == -1)
 629                                 ThrowArgumentException (value);
 630                         return rval;
 631                 }
 632
 633                 //
 634                 // Non-generated exports
 635                 //
 636
 637                 // convert from octal representation.
 638                 public static FilePermissions ToFilePermissions (string value)
 639                 {
 640                         uint n = Convert.ToUInt32 (value, 8);
 641                         return ToFilePermissions (n);
 642                 }
 643
 644                 public static readonly DateTime LocalUnixEpoch =
 645                         new DateTime (1970, 1, 1).ToLocalTime();
 646                 public static readonly long UtcOffset =
 647                         (long) (DateTime.Now.Subtract (DateTime.UtcNow).TotalSeconds);
 648
 649                 public static DateTime ToDateTime (long time)
 650                 {
 651                         return FromTimeT (time);
 652                 }
 653
 654                 public static long FromDateTime (DateTime time)
 655                 {
 656                         return ToTimeT (time);
 657                 }
 658
 659                 public static DateTime FromTimeT (long time)
 660                 {
 661                         // Console.WriteLine ("** LocalUnixEpoch={0}; UtcOffset={1}; time={2}", LocalUnixEpoch, UtcOffset, time);
 662
 663                         DateTime r = LocalUnixEpoch.AddSeconds (time + UtcOffset);
 664                         // Console.WriteLine ("** result={0}", r);
 665                         return r;
 666                 }
 667
 668                 public static long ToTimeT (DateTime time)
 669                 {
 670                         return (long) time.Subtract (LocalUnixEpoch).TotalSeconds;
 671                 }
 672         }
 673 }
 674
 675 // vim: noexpandtab