aboutsummaryrefslogtreecommitdiff
path: root/src/stable/file.h
blob: 22f1d205285e6e9d9b85263f7ba5adaa6064d59f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*
 * Copyright (C) 2007-2013 Xagasoft, All rights reserved.
 *
 * This file is part of the libbu++ library and is released under the
 * terms of the license contained in the file LICENSE.
 */

#ifndef BU_FILE_H
#define BU_FILE_H

#include <stdint.h>
#include <sys/types.h>

#include "bu/stream.h"
#include "bu/string.h"
#include "bu/exceptionbase.h"

namespace Bu
{
    subExceptionDecl( FileException );

    /**
     * A file stream.
     *@ingroup Streams
     */
    class File : public Bu::Stream
    {
    public:
        File( const Bu::String &sName, int iFlags );
        File( int fd );
        virtual ~File();

        virtual void close();
        virtual Bu::size read( void *pBuf, Bu::size nBytes );
        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
        using Stream::write;

        virtual Bu::size tell();
        virtual void seek( Bu::size offset );
        virtual void setPos( Bu::size pos );
        virtual void setPosEnd( Bu::size pos );
        virtual bool isEos();
        virtual bool isOpen();

        virtual void flush();

        virtual bool canRead();
        virtual bool canWrite();

        virtual bool isReadable();
        virtual bool isWritable();
        virtual bool isSeekable();

        virtual bool isBlocking();
        virtual void setBlocking( bool bBlocking=true );

        enum {
            // Flags
            Read        = 0x01, ///< Open file for reading
            Write       = 0x02, ///< Open file for writing
            Create      = 0x04, ///< Create file if it doesn't exist
            Truncate    = 0x08, ///< Truncate file if it does exist
            Append      = 0x10, ///< Always append on every write
            NonBlock    = 0x20, ///< Open file in non-blocking mode
            Exclusive   = 0x44, ///< Create file, if it exists then fail

            // Helpful mixes
            ReadWrite   = 0x03, ///< Open for reading and writing
            WriteNew    = 0x0E  ///< Create a file (or truncate) for writing.
                                /// Same as Write|Create|Truncate
        };

        virtual void setSize( Bu::size iSize );

        virtual size getSize() const;
        virtual size getBlockSize() const;
        virtual Bu::String getLocation() const;

        /**
         * Create a temp file and return its handle.  The file is opened 
         * Read/Write.
         *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
         *      It will alter your (sName) setting the 'X's to random
         *      characters.
         *@returns (Bu::File) A file object representing your temp file.
         */
        static Bu::File tempFile( Bu::String &sName );

#ifndef WIN32
        /**
         * Change the file access permissions.
         *@param t (mode_t) The new file access permissions.
         */
        void chmod( mode_t t );
#endif

    private:
        int getPosixFlags( int iFlags );

    private:
        int fd;
        bool bEos;
    };
}

#endif