l_stdio_wrap.h

Go to the documentation of this file.

/*
 * $Id: l_stdio_wrap.h 17249 2014-08-07 16:03:32Z predoehl $
 */

/* =========================================================================== *
|
|  Copyright (c) 2012 by Kobus Barnard and Andrew Predoehl.
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT sista DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
* =========================================================================== */


#ifndef L_STDIO_WRAP_H_UOFARIZONA_VISION
#define L_STDIO_WRAP_H_UOFARIZONA_VISION

#include <l/l_sys_lib.h>
#include <l/l_sys_io.h>
#include <l/l_error.h>
#include <l/l_global.h>
#include <l_cpp/l_exception.h>

#include <string>
#include <boost/scoped_ptr.hpp>

namespace kjb {


class File_Ptr {
    FILE* m_fp; 

    File_Ptr( const File_Ptr& ); // teaser -- this is a non-copyable class
    File_Ptr& operator=( const File_Ptr& ); // teaser -- non-assignable too

protected:

    void throw_io_error( const std::string& pathname, const char* mode )
    {
        KJB_THROW_2( kjb::IO_error, "Unable to open " + pathname
                                                    + " with mode " + mode );
    }

    File_Ptr( const std::string& pathname, const char* mode )
    :   m_fp( kjb_c::kjb_fopen( pathname.c_str(), mode ) )
    {
        if ( 0 == m_fp )
        {
            throw_io_error( pathname, mode );
        }
    }

    File_Ptr()
    :   m_fp( 0 )
    {}

    void swap( File_Ptr& that )
    {
        std::swap( m_fp, that.m_fp );
    }

public:

    virtual int close()
    {
        int rc = kjb_c::kjb_fclose( m_fp );
        m_fp = 0;
        return rc;
    }

    virtual ~File_Ptr()
    {
        close();
    }

    operator FILE*() const
    {
        return m_fp;
    }
};

struct File_Ptr_Read : public File_Ptr {
    File_Ptr_Read( const std::string& pathname )
    :   File_Ptr( pathname, "r" )
    {}
};

struct File_Ptr_Write : public File_Ptr {
    File_Ptr_Write( const std::string& pathname )
    :   File_Ptr( pathname, "w" )
    {}
};

struct File_Ptr_Append : public File_Ptr {
    File_Ptr_Append( const std::string& pathname )
    :   File_Ptr( pathname, "a" )
    {}
};

struct File_Ptr_Read_Plus : public File_Ptr {
    File_Ptr_Read_Plus( const std::string& pathname )
    :   File_Ptr( pathname, "r+" )
    {}
};

// If you need a mode like w+ or a+ then please add a new derived class




class Temporary_File : public File_Ptr {
#ifdef UNIX_SYSTEM

    std::string m_filename; 

public:

    Temporary_File();

    int close()
    {
        int rc1 = 0, rc2 = 0;
        if ( m_filename.size() )
        {
            rc1 = File_Ptr::close();
            rc2 = kjb_c::kjb_unlink( m_filename.c_str() );
            m_filename.clear();
        }
        return rc1 | rc2;
    }

    ~Temporary_File()
    {
        close();
    }

    const std::string& get_filename() const
    {
        return m_filename;
    }

#else /* UNIX_SYSTEM above, non-unix below. */
#warning "On non-Unix style systems, class Temporary_File does not work."
public:
    Temporary_File() {}
    int close() { return 0; }
    const std::string& get_filename() const { return ""; }
#endif /* UNIX_SYSTEM (or not) */
};


class Temporary_Directory {

    std::string m_pathname;

    bool m_silence;

    // this item is non-copyable and non-assignable
    Temporary_Directory(const Temporary_Directory&); // copy ctor teaser
    Temporary_Directory& operator=(const Temporary_Directory&); // teaser

#ifdef UNIX_SYSTEM

    int do_rmdir() const
    {
        return kjb_c::kjb_rmdir( m_pathname.c_str() );
    }

    int do_rmrf() const
    {
        return kjb_c::kjb_system( ("rm -rf " + m_pathname).c_str() );
    }

    int do_the_cleaning(
        int( Temporary_Directory::* pf_cleaning )() const,
        const std::string& fail_func
    )
    {
        using namespace kjb_c;
        ASSERT( pf_cleaning );
        if ( 0 == m_pathname.size() ) return NO_ERROR;

        int rc = (this ->* pf_cleaning)();
        if ( ! is_directory( m_pathname.c_str() ) ) m_pathname.clear();

        if ( ERROR == rc )
        {
            add_error(("Temporary_Directory::"+ fail_func +" failed").c_str());
        }
        return rc;
    }

public:

    Temporary_Directory();

    int remove()
    {
        return do_the_cleaning( & Temporary_Directory::do_rmdir, __func__ );
    }

    int recursively_remove()
    {
        return do_the_cleaning( & Temporary_Directory::do_rmrf, __func__ );
    }

    virtual ~Temporary_Directory()
    {
        int status = remove();
        if (!m_silence)
        {
            using namespace kjb_c;
            EPE(status);
        }
    }

#else /* UNIX_SYSTEM above, non-unix below. */
#warning "On non-Unix style systems, class Temporary_Directory does not work."
public:
    Temporary_Directory() {}
    int remove()                { return kjb_c::NO_ERROR; }
    int recursively_remove()    { return kjb_c::NO_ERROR; }
#endif /* UNIX_SYSTEM (or not) */

    const std::string& get_pathname() const
    {
        return m_pathname;
    }

    bool set_silence_flag(bool new_silence_setting = true)
    {
        std::swap(m_silence, new_silence_setting);
        return new_silence_setting;
    }
};


struct Temporary_Recursively_Removing_Directory : public Temporary_Directory
{
    Temporary_Recursively_Removing_Directory()
    {
    }

    ~Temporary_Recursively_Removing_Directory()
    {
        using namespace kjb_c;
        EPE( recursively_remove() );
    }

#ifndef UNIX_SYSTEM
#warning "class Temporary_Recursively_Removing_Directory unavailable w/o Unix."
#endif
};



class File_Ptr_Smart_Read : public File_Ptr {
#ifdef UNIX_SYSTEM

    boost::scoped_ptr< Temporary_File > temp;

    void attempt_unzip( const std::string& );

public:

    File_Ptr_Smart_Read( const std::string& filename )
    {
        try
        {
            File_Ptr_Read fp( filename );
            File_Ptr::swap( fp );
        }
        catch( kjb::IO_error& )
        {
            attempt_unzip( filename );
        }
    }

    std::string get_temp_filename() const
    {
        if ( temp )
        {
            return temp -> get_filename();
        }
        return "";
    }

#else /* UNIX_SYSTEM above, non-unix below. */
#warning "On non-Unix style systems, class File_Ptr_Smart_Read does not work."
public:
    File_Ptr_Smart_Read( const std::string& fn ) : File_Ptr_Read( fn ) {}
    std::string get_temp_filename() const { return ""; }
#endif /* UNIX_SYSTEM (or not) */
};


int getline( FILE* fp, std::string* line, char EOL = '\n' );


} //namespace kjb

#endif /* L_STDIO_WRAP_H_UOFARIZONA_VISION */