scoped.h

Go to the documentation of this file.

#ifndef __scoped_h__
#define __scoped_h__
 
/*
  template functions for scoped object handling
    Copyright (C) 2018  Juergen Hannappel
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
 
#include <throwcall.h>
 
namespace scoped {
    // this is a simple amateuric attempt to achive what is described here:
    // http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e19-use-a-final_action-object-to-express-cleanup-if-no-suitable-resource-handle-is-available
    // https://www.bfilipek.com/2017/04/finalact.html
    template <typename T> class generic {
        T& finishItem;
        typedef void (*finisherType)(T&);
        finisherType finisher;
      public:
        generic(T& stopItem, finisherType Finisher):
            finishItem(stopItem),
            finisher(Finisher) {
        }
        ~generic() {
            finisher(finishItem);
        }
    };
 
    class Fd {
        int fd;
        const std::string& name;
      public:
        Fd(const std::string& Name, int _Fd):
            fd(_Fd),
            name(Name) {
        }
        ~Fd() {
            if (fd != -1) { // don't choke on non-open files...
                throwcall::good0(close(fd), "can't close ", name);
            }
        }
        int operator() () {
            return fd;
        }
        operator int () {
            return fd;
        }
        operator int () const {
            return fd;
        }
    };
    class Dir {
        DIR* dir;
        const std::string& name;
      public:
        Dir(const std::string& Name, DIR* _Dir):
            dir(_Dir),
            name(Name) {
        }
        Dir(const std::string& Name):
            name(Name) {
            dir = throwcall::badval(opendir(name.c_str()),
                                    nullptr, "can't open directory", name);
        }
        ~Dir() {
            if (dir != nullptr) { // don't choke on non-open files...
                throwcall::good0(closedir(dir), "can't close ", name);
            }
        }
        DIR* operator() () {
            return dir;
        }
        operator DIR* () {
            return dir;
        }
    };
} // end of namespace scoped
 
#endif