islibfunc.cpp

   1 //
   2 // Inclusion of standard header file
   3 //
   4 #include <cerrno>
   5 #include <cmath>
   6 #include <cstdio>
   7 #include <cstddef>
   8 #include <ctime>
   9 #include <string>
  10 #include <string.h>
  11 #include <sstream>
  12 #include <stdexcept>
  13
  14 //
  15 // Inclusion of system header file
  16 //
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <signal.h>
  20 #include <unistd.h>
  21 #include <utime.h>
  22
  23 //
  24 // Inclusion of library header file
  25 //
  26 #include <boost/filesystem/path.hpp>
  27
  28 //
  29 // Inclusion of local header file
  30 //
  31 #include "fatal_error.hpp"
  32 #include "islibfunc.hpp"
  33 #include "system_error.hpp"
  34
  35 namespace islib
  36   {
  37     //
  38     // Definition of function
  39     //
  40     void
  41     link_
  42       (
  43         boost::filesystem::path const &source_file_path,
  44         boost::filesystem::path const &destination_file_path
  45       )
  46       {
  47         class local
  48           {
  49           public:
  50             local
  51               (
  52                 boost::filesystem::path const &source_file_path_,
  53                 boost::filesystem::path const &destination_file_path_
  54               )
  55               {
  56                 throw_if ( std::invalid_argument ( "islib::link_: source_file_path_.empty ()" ), source_file_path_.empty () );
  57                 throw_if ( std::invalid_argument ( "islib::link_: destination_file_path_.empty ()" ), destination_file_path_.empty () );
  58               }
  59
  60             ~local
  61               ()
  62               throw
  63                 ()
  64               {
  65               }
  66           }
  67         a_local ( source_file_path, destination_file_path );
  68
  69         int link_return_value = link ( source_file_path.string ().c_str (), destination_file_path.string ().c_str () );
  70
  71         if ( link_return_value != 0 )
  72           {
  73             int const saved_errno = errno;
  74             char buffer [ BUFSIZ ];
  75             std::stringstream system_error_message_stream;
  76
  77             system_error_message_stream << "islib::link_: link: " << strerror_r ( saved_errno, buffer, BUFSIZ );
  78
  79             throw_ ( system_error ( system_error_message_stream.str () ) );
  80           }
  81       }
  82
  83     //
  84     // Definition of function
  85     //
  86     void
  87     localtime_r_
  88       (
  89         std::time_t const * const time,
  90         struct std::tm * const time_information
  91       )
  92       {
  93         class local
  94           {
  95           public:
  96             local
  97               (
  98                 std::time_t const * const time_,
  99                 struct std::tm * const time_information_
 100               )
 101               {
 102                 throw_if ( std::invalid_argument ( "islib::localtime_r_: !time_" ), !time_ );
 103                 throw_if ( std::invalid_argument ( "islib::localtime_r_: !time_information_" ), !time_information_ );
 104               }
 105
 106             ~local
 107               ()
 108               throw
 109                 ()
 110               {
 111               }
 112           }
 113         a_local ( time, time_information );
 114
 115         struct tm * const localtime_r_return_value = localtime_r ( time, time_information );
 116
 117         if ( localtime_r_return_value == 0 )
 118           {
 119             int const saved_errno = errno;
 120             char buffer [ BUFSIZ ];
 121             std::stringstream system_error_message_stream;
 122
 123             system_error_message_stream << "islib::localtime_r_: std::localtime_r: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 124
 125             throw_ ( system_error ( system_error_message_stream.str () ) );
 126           }
 127       }
 128
 129     //
 130     // Definition of function
 131     //
 132     void
 133     mkdir_
 134       (
 135         boost::filesystem::path const &directory_path,
 136         mode_t mode
 137       )
 138       {
 139         class local
 140           {
 141           public:
 142             local
 143               (
 144                 boost::filesystem::path const &directory_path_
 145               )
 146               {
 147                 throw_if ( std::invalid_argument ( "islib::mkdir_: directory_path_.empty ()" ), directory_path_.empty () );
 148               }
 149
 150             ~local
 151               ()
 152               throw
 153                 ()
 154               {
 155               }
 156           }
 157         a_local ( directory_path );
 158
 159         int mkdir_return_value = mkdir ( directory_path.string ().c_str (), mode );
 160
 161         if ( mkdir_return_value != 0 )
 162           {
 163             int const saved_errno = errno;
 164             char buffer [ BUFSIZ ];
 165             std::stringstream system_error_message_stream;
 166
 167             system_error_message_stream << "islib::mkdir_: mkdir: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 168
 169             throw_ ( system_error ( system_error_message_stream.str () ) );
 170           }
 171       }
 172
 173     //
 174     // Definition of function
 175     //
 176     void
 177     raise_
 178       (
 179         int const signal_number
 180       )
 181       {
 182         class local
 183           {
 184           public:
 185             local
 186               (
 187                 int const signal_number_
 188               )
 189               {
 190                 throw_if ( std::invalid_argument ( "islib::raise_: signal_number_ < 1 || _NSIG <= signal_number_" ), signal_number_ < 1 || _NSIG <= signal_number_ );
 191               }
 192
 193             ~local
 194               ()
 195               throw
 196                 ()
 197               {
 198               }
 199           }
 200         a_local ( signal_number );
 201
 202         int const raise_return_value = raise ( signal_number );
 203
 204         if ( raise_return_value != 0 )
 205           {
 206             int const saved_errno = errno;
 207             char buffer [ BUFSIZ ];
 208             std::stringstream system_error_message_stream;
 209
 210             system_error_message_stream << "islib::raise_: raise: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 211
 212             throw_ ( system_error ( system_error_message_stream.str () ) );
 213           }
 214       }
 215
 216     //
 217     // Definition of function
 218     //
 219     void
 220     raise_fatal
 221       (
 222         int const signal_number
 223       )
 224       {
 225         class local
 226           {
 227           public:
 228             local
 229               (
 230                 int const signal_number_
 231               )
 232               {
 233                 throw_if ( fatal_error ( "islib::raise_fatal: signal_number_ < 1 || _NSIG <= signal_number_" ), signal_number_ < 1 || _NSIG <= signal_number_ );
 234               }
 235
 236             ~local
 237               ()
 238               throw
 239                 ()
 240               {
 241               }
 242           }
 243         a_local ( signal_number );
 244
 245         int const raise_return_value = raise ( signal_number );
 246
 247         if ( raise_return_value != 0 )
 248           throw_ ( fatal_error ( "islib::raise_fatal: raise: fatal error." ) );
 249       }
 250
 251     //
 252     // Definition of function
 253     //
 254     void
 255     sigaction_
 256       (
 257         int const signal_number,
 258         struct sigaction const * const signal_action,
 259         struct sigaction * const old_signal_action
 260       )
 261       {
 262         class local
 263           {
 264           public:
 265             local
 266               (
 267                 int const signal_number_,
 268                 struct sigaction const * const signal_action_
 269               )
 270               {
 271                 throw_if ( std::invalid_argument ( "islib::sigaction_: signal_number_ < 1 || _NSIG <= signal_number_" ), signal_number_ < 1 || _NSIG <= signal_number_ );
 272                 throw_if ( std::invalid_argument ( "islib::sigaction_: !signal_action_" ), !signal_action_ );
 273               }
 274
 275             ~local
 276               ()
 277               throw
 278                 ()
 279               {
 280               }
 281           }
 282         a_local ( signal_number, signal_action );
 283
 284         int const sigaction_return_value = sigaction ( signal_number, signal_action, old_signal_action );
 285
 286         if ( sigaction_return_value != 0 )
 287           {
 288             int const saved_errno = errno;
 289             char buffer [ BUFSIZ ];
 290             std::stringstream system_error_message_stream;
 291
 292             system_error_message_stream << "islib::sigaction_: sigaction: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 293
 294             throw_ ( system_error ( system_error_message_stream.str () ) );
 295           }
 296       }
 297
 298     //
 299     // Definition of function
 300     //
 301     void
 302     sigaction_fatal
 303       (
 304         int const signal_number,
 305         struct sigaction const * const signal_action,
 306         struct sigaction * const old_signal_action
 307       )
 308       {
 309         class local
 310           {
 311           public:
 312             local
 313               (
 314                 int const signal_number_,
 315                 struct sigaction const * const signal_action_
 316               )
 317               {
 318                 throw_if ( fatal_error ( "islib::sigaction_fatal: signal_number_ < 1 || _NSIG <= signal_number_" ), signal_number_ < 1 || _NSIG <= signal_number_ );
 319                 throw_if ( fatal_error ( "islib::sigaction_fatal: !signal_action_" ), !signal_action_ );
 320               }
 321
 322             ~local
 323               ()
 324               throw
 325                 ()
 326               {
 327               }
 328           }
 329         a_local ( signal_number, signal_action );
 330
 331         int const sigaction_return_value = sigaction ( signal_number, signal_action, old_signal_action );
 332
 333         if ( sigaction_return_value != 0 )
 334           throw_ ( fatal_error ( "islib::sigaction_fatal: sigaction: fatal error." ) );
 335       }
 336
 337     //
 338     // Definition of function
 339     //
 340     void
 341     sigfillset_
 342       (
 343         sigset_t * const signal_set
 344       )
 345       {
 346         class local
 347           {
 348           public:
 349             local
 350               (
 351                 sigset_t * const signal_set_
 352               )
 353               {
 354                 throw_if ( std::invalid_argument ( "islib::sigfillset_: !signal_set_" ), !signal_set_ );
 355               }
 356
 357             ~local
 358               ()
 359               throw
 360                 ()
 361               {
 362               }
 363           }
 364         a_local ( signal_set );
 365
 366         int const sigfillset_return_value = sigfillset ( signal_set );
 367
 368         if ( sigfillset_return_value != 0 )
 369           {
 370             int const saved_errno = errno;
 371             char buffer [ BUFSIZ ];
 372             std::stringstream system_error_message_stream;
 373
 374             system_error_message_stream << "islib::sigfillset_: sigfillset: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 375
 376             throw_ ( system_error ( system_error_message_stream.str () ) );
 377           }
 378       }
 379
 380     //
 381     // Definition of function
 382     //
 383     void
 384     sigfillset_fatal
 385       (
 386         sigset_t * const signal_set
 387       )
 388       {
 389         class local
 390           {
 391           public:
 392             local
 393               (
 394                 sigset_t * const signal_set_
 395               )
 396               {
 397                 throw_if ( fatal_error ( "islib::sigfillset_fatal: !signal_set_" ), !signal_set_ );
 398               }
 399
 400             ~local
 401               ()
 402               throw
 403                 ()
 404               {
 405               }
 406           }
 407         a_local ( signal_set );
 408
 409         int const sigfillset_return_value = sigfillset ( signal_set );
 410
 411         if ( sigfillset_return_value != 0 )
 412           throw_ ( fatal_error ( "islib::sigfillset_fatal: sigfillset: fatal error." ) );
 413       }
 414
 415     //
 416     // Definition of function
 417     //
 418     void
 419     sigprocmask_
 420       (
 421         int const mode,
 422         sigset_t const * const signal_set,
 423         sigset_t * const old_signal_set
 424       )
 425       {
 426         class local
 427           {
 428           public:
 429             local
 430               (
 431                 int const mode_,
 432                 sigset_t const * const signal_set_
 433               )
 434               {
 435                 throw_if ( std::invalid_argument ( "islib::sigprocmask_: mode_ != SIG_BLOCK && mode_ != SIG_UNBLOCK && mode_ != SIG_SETMASK" ), mode_ != SIG_BLOCK && mode_ != SIG_UNBLOCK && mode_ != SIG_SETMASK );
 436                 throw_if ( std::invalid_argument ( "islib::sigprocmask_: !signal_set_" ), !signal_set_ );
 437               }
 438
 439             ~local
 440               ()
 441               throw
 442                 ()
 443               {
 444               }
 445           }
 446         a_local ( mode, signal_set );
 447
 448         int const sigprocmask_return_value = sigprocmask ( mode, signal_set, old_signal_set );
 449
 450         if ( sigprocmask_return_value != 0 )
 451           {
 452             int const saved_errno = errno;
 453             char buffer [ BUFSIZ ];
 454             std::stringstream system_error_message_stream;
 455
 456             system_error_message_stream << "islib::sigprocmask_: sigprocmask: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 457
 458             throw_ ( system_error ( system_error_message_stream.str () ) );
 459           }
 460       }
 461
 462     //
 463     // Definition of function
 464     //
 465     void
 466     sigprocmask_fatal
 467       (
 468         int const mode,
 469         sigset_t const * const signal_set,
 470         sigset_t * const old_signal_set
 471       )
 472       {
 473         class local
 474           {
 475           public:
 476             local
 477               (
 478                 int const mode_,
 479                 sigset_t const * const signal_set_
 480               )
 481               {
 482                 throw_if ( fatal_error ( "islib::sigprocmask_fatal: mode_ != SIG_BLOCK && mode_ != SIG_UNBLOCK && mode_ != SIG_SETMASK" ), mode_ != SIG_BLOCK && mode_ != SIG_UNBLOCK && mode_ != SIG_SETMASK );
 483                 throw_if ( fatal_error ( "islib::sigprocmask_fatal_: !signal_set_" ), !signal_set_ );
 484               }
 485
 486             ~local
 487               ()
 488               throw
 489                 ()
 490               {
 491               }
 492           }
 493         a_local ( mode, signal_set );
 494
 495         int const sigprocmask_return_value = sigprocmask ( mode, signal_set, old_signal_set );
 496
 497         if ( sigprocmask_return_value != 0 )
 498           throw_ ( fatal_error ( "islib::sigprocmask_fatal: sigprocmask: fatal error." ) );
 499       }
 500
 501     //
 502     // Definition of function
 503     //
 504     void
 505     stat_
 506       (
 507         boost::filesystem::path const &path,
 508         struct stat * const status_information
 509       )
 510       {
 511         class local
 512           {
 513           public:
 514             local
 515               (
 516                 boost::filesystem::path const &path_,
 517                 struct stat * const status_information_
 518               )
 519               {
 520                 throw_if ( std::invalid_argument ( "islib::stat_: path_.empty ()" ), path_.empty () );
 521                 throw_if ( std::invalid_argument ( "islib::stat_: !status_information_" ), !status_information_ );
 522               }
 523
 524             ~local
 525               ()
 526               throw
 527                 ()
 528               {
 529               }
 530           }
 531         a_local ( path, status_information );
 532
 533         int const stat_return_value = stat ( path.string ().c_str (), status_information );
 534
 535         if ( stat_return_value != 0 )
 536           {
 537             int const saved_errno = errno;
 538             char buffer [ BUFSIZ ];
 539             std::stringstream system_error_message_stream;
 540
 541             system_error_message_stream << "islib::stat_: stat: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 542
 543             throw_ ( system_error ( system_error_message_stream.str () ) );
 544           }
 545       }
 546
 547     //
 548     // Definition of function
 549     //
 550     std::time_t
 551     time
 552       (
 553       )
 554       {
 555         std::time_t time_;
 556
 557         std::time_t time_return_value = std::time ( &time_ );
 558
 559         if ( time_return_value == -1 )
 560           {
 561             int const saved_errno = errno;
 562             char buffer [ BUFSIZ ];
 563             std::stringstream system_error_message_stream;
 564
 565             system_error_message_stream << "islib::time: std::time: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 566
 567             throw_ ( system_error ( system_error_message_stream.str () ) );
 568           }
 569
 570         return time_;
 571       }
 572
 573     //
 574     // Definition of function
 575     //
 576     void
 577     unlink_
 578       (
 579         boost::filesystem::path const &file_path
 580       )
 581       {
 582         class local
 583           {
 584           public:
 585             local
 586               (
 587                 boost::filesystem::path const &file_path_
 588               )
 589               {
 590                 throw_if ( std::invalid_argument ( "islib::unlink_: file_path_.empty ()" ), file_path_.empty () );
 591               }
 592
 593             ~local
 594               ()
 595               throw
 596                 ()
 597               {
 598               }
 599           }
 600         a_local ( file_path );
 601
 602         int unlink_return_value = unlink ( file_path.string ().c_str () );
 603
 604         if ( unlink_return_value != 0 )
 605           {
 606             int const saved_errno = errno;
 607             char buffer [ BUFSIZ ];
 608             std::stringstream system_error_message_stream;
 609
 610             system_error_message_stream << "islib::unlink_: unlink: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 611
 612             throw_ ( system_error ( system_error_message_stream.str () ) );
 613           }
 614       }
 615
 616     //
 617     // Definition of function
 618     //
 619     void
 620     utime_
 621       (
 622         boost::filesystem::path const &path,
 623         struct utimbuf const * const utime_information
 624       )
 625       {
 626         class local
 627           {
 628           public:
 629             local
 630               (
 631                 boost::filesystem::path const &path_,
 632                 struct utimbuf const * const utime_information_
 633               )
 634               {
 635                 throw_if ( std::invalid_argument ( "islib::utime_: path_.empty ()" ), path_.empty () );
 636                 throw_if ( std::invalid_argument ( "islib::utime_: !utime_information_" ), !utime_information_ );
 637               }
 638
 639             ~local
 640               ()
 641               throw
 642                 ()
 643               {
 644               }
 645           }
 646         a_local ( path, utime_information );
 647
 648         int utime_return_value = utime ( path.string ().c_str (), utime_information );
 649
 650         if ( utime_return_value != 0 )
 651           {
 652             int const saved_errno = errno;
 653             char buffer [ BUFSIZ ];
 654             std::stringstream system_error_message_stream;
 655
 656             system_error_message_stream << "islib::utime_: utime: " << strerror_r ( saved_errno, buffer, BUFSIZ );
 657
 658             throw_ ( system_error ( system_error_message_stream.str () ) );
 659           }
 660       }
 661
 662     //
 663     // Definition of function
 664     //
 665     void
 666     write_
 667       (
 668         int const file_descriptor,
 669         void const *buffer,
 670         std::size_t const number_of_bytes
 671       )
 672       {
 673         class local
 674           {
 675           public:
 676             local
 677               (
 678                 int const file_descriptor_,
 679                 void const *buffer_
 680               )
 681               {
 682                 throw_if ( std::invalid_argument ( "islib::write_: file_descriptor_ < 0" ), file_descriptor_ < 0 );
 683                 throw_if ( std::invalid_argument ( "islib::write_: !buffer_" ), !buffer_ );
 684               }
 685
 686             ~local
 687               ()
 688               throw
 689                 ()
 690               {
 691               }
 692           }
 693         a_local ( file_descriptor, buffer );
 694
 695         ssize_t const write_return_value = write ( file_descriptor, buffer, number_of_bytes );
 696
 697         if ( write_return_value == -1 )
 698           {
 699             int const saved_errno = errno;
 700             char buffer_ [ BUFSIZ ];
 701             std::stringstream system_error_message_stream;
 702
 703             system_error_message_stream << "islib::write_: write: " << strerror_r ( saved_errno, buffer_, BUFSIZ );
 704
 705             throw_ ( system_error ( system_error_message_stream.str () ) );
 706           }
 707       }
 708
 709     //
 710     // Definition of function
 711     //
 712     void
 713     write_assert
 714       (
 715         int const file_descriptor,
 716         void const *buffer,
 717         std::size_t const number_of_bytes
 718       )
 719       {
 720         class local
 721           {
 722           public:
 723             local
 724               (
 725                 int const file_descriptor_,
 726                 void const *buffer_
 727               )
 728               {
 729                 throw_if ( fatal_error ( "islib::write_: file_descriptor_ < 0" ), file_descriptor_ < 0 );
 730                 throw_if ( fatal_error ( "islib::write_: !buffer_" ), !buffer_ );
 731               }
 732
 733             ~local
 734               ()
 735               throw
 736                 ()
 737               {
 738               }
 739           }
 740         a_local ( file_descriptor, buffer );
 741
 742         ssize_t const write_return_value = write ( file_descriptor, buffer, number_of_bytes );
 743
 744         assert_ ( write_return_value != -1, "islib::write_: `write_return_value != -1' has failed." );
 745       }
 746
 747     //
 748     // Definition of specialized template function
 749     //
 750     template
 751       <
 752       >
 753     bool
 754     equals_to
 755       <
 756         double,
 757         double
 758       >
 759       (
 760         double const &x,
 761         double const &y,
 762         double const &permissible_error
 763       )
 764       {
 765         return std::fabs ( x - y ) <= permissible_error;
 766       }
 767
 768     //
 769     // Definition of specialized template function
 770     //
 771     template
 772       <
 773       >
 774     bool
 775     does_not_equal_to
 776       <
 777         double,
 778         double
 779       >
 780       (
 781         double const &x,
 782         double const &y,
 783         double const &permissible_error
 784       )
 785       {
 786         return std::fabs ( x - y ) > permissible_error;
 787       }
 788
 789     //
 790     // Definition of specialized template function
 791     //
 792     template
 793       <
 794       >
 795     bool
 796     is_less_than
 797       <
 798         double,
 799         double
 800       >
 801       (
 802         double const &x,
 803         double const &y,
 804         double const &permissible_error
 805       )
 806       {
 807         return y - x > permissible_error;
 808       }
 809
 810     //
 811     // Definition of specialized template function
 812     //
 813     template
 814       <
 815       >
 816     bool
 817     is_greater_than
 818       <
 819         double,
 820         double
 821       >
 822       (
 823         double const &x,
 824         double const &y,
 825         double const &permissible_error
 826       )
 827       {
 828         return x - y > permissible_error;
 829       }
 830
 831     //
 832     // Definition of specialized template function
 833     //
 834     template
 835       <
 836       >
 837     bool
 838     is_less_than_or_equals_to
 839       <
 840         double,
 841         double
 842       >
 843       (
 844         double const &x,
 845         double const &y,
 846         double const &permissible_error
 847       )
 848       {
 849         return x - y <= permissible_error;
 850       }
 851
 852     //
 853     // Definition of specialized template function
 854     //
 855     template <>
 856     bool
 857     is_greater_than_or_equals_to
 858       <
 859         double,
 860         double
 861       >
 862       (
 863         double const &x,
 864         double const &y,
 865         double const &permissible_error
 866       )
 867       {
 868         return y - x <= permissible_error;
 869       }
 870   }
 871
 872 //
 873 // End of file
 874 //