This file is indexed.

/usr/include/fox-1.6/FXIO.h is in libfox-1.6-dev 1.6.49-2ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/********************************************************************************
*                                                                               *
*                        I / O   D e v i c e   C l a s s                        *
*                                                                               *
*********************************************************************************
* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or                 *
* modify it under the terms of the GNU Lesser General Public                    *
* License as published by the Free Software Foundation; either                  *
* version 2.1 of the License, or (at your option) any later version.            *
*                                                                               *
* This library 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             *
* Lesser General Public License for more details.                               *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public              *
* License along with this library; if not, write to the Free Software           *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
*********************************************************************************
* $Id: FXIO.h,v 1.8 2006/01/22 17:58:04 fox Exp $                               *
********************************************************************************/
#ifndef FXIO_H
#define FXIO_H



namespace FX {


/**
* FXIO manipulates a handle to an abstract i/o device.
* The various subclasses of FXIO perform i/o on files, sockets,
* pipes, and possibly other devices.
*/
class FXAPI FXIO {
protected:
  FXInputHandle device;         // Device (file/pipe/socket/whatever)
  FXuint        access;         // Access being performed
private:
  FXIO(const FXIO&);
  FXIO &operator=(const FXIO&);
public:

  /// File modes
  enum {

    /// Permissions
    OtherRead      = 0x00004,   /// Others have read permission
    OtherWrite     = 0x00002,   /// Others have write permisson
    OtherExec      = 0x00001,   /// Others have execute permission
    OtherReadWrite = 0x00006,   /// Others have read and write permission
    OtherFull      = 0x00007,   /// Others have full access

    GroupRead      = 0x00020,   /// Group has read permission
    GroupWrite     = 0x00010,   /// Group has write permission
    GroupExec      = 0x00008,   /// Group has execute permission
    GroupReadWrite = 0x00030,   /// Group has read and write permission
    GroupFull      = 0x00038,   /// Group has full access

    OwnerRead      = 0x00100,   /// Owner has read permission
    OwnerWrite     = 0x00080,   /// Owner has write permission
    OwnerExec      = 0x00040,   /// Owner has execute permission
    OwnerReadWrite = 0x00180,   /// Owner has read and write permission
    OwnerFull      = 0x001C0,   /// Owner has full access

    /// Other flags
    Hidden         = 0x00200,   /// Hidden file
    Directory      = 0x00400,   /// Is directory
    File           = 0x00800,   /// Is regular file
    SymLink        = 0x01000,   /// Is symbolic link

    /// Special mode bits
    SetUser        = 0x02000,   /// Set user id
    SetGroup       = 0x04000,   /// Set group id
    Sticky         = 0x08000,   /// Sticky bit

    /// Device special files
    Character      = 0x10000,   /// Character device
    Block          = 0x20000,   /// Block device
    Socket         = 0x40000,   /// Socket device
    Fifo           = 0x80000    /// Fifo device
    };

  /// Access modes
  enum {

    /// Basic access options
    NoAccess    =  0,                           /// No access
    ReadOnly    =  1,                           /// Open for reading
    WriteOnly   =  2,                           /// Open for writing
    ReadWrite   =  3,                           /// Open for read and write
    Append      =  4,                           /// Open for append
    Truncate    =  8,                           /// Truncate to zero when writing
    Create      = 16,                           /// Create if it doesn't exist
    Exclusive   = 32,                           /// Fail if trying to create a file which already exists
    NonBlocking = 64,                           /// Non-blocking i/o

    /// Convenience access options
    Reading     = ReadOnly,                     /// Normal options for reading
    Writing     = ReadWrite|Create|Truncate     /// Normal options for writing
    };

  /// Positioning modes
  enum {
    Begin   = 0,                /// Position from the begin (default)
    Current = 1,                /// Position relative to current position
    End     = 2                 /// Position from the end
    };

public:

  /// Construct
  FXIO();

  /// Open device with access mode and handle
  virtual bool open(FXInputHandle handle,FXuint mode);

  /// Return true if open
  virtual bool isOpen() const;

  /// Return access mode
  FXuint mode() const { return access; }

  /// Return handle
  FXInputHandle handle() const { return device; }

  /// Attach existing device handle
  virtual void attach(FXInputHandle handle,FXuint mode);

  /// Detach device handle
  virtual void detach();

  /// Get current file position
  virtual FXlong position() const;

  /// Change file position, returning new position from start
  virtual FXlong position(FXlong offset,FXuint from=FXIO::Begin);

  /// Read block of bytes, returning number of bytes read
  virtual FXival readBlock(void* data,FXival count);

  /// Write block of bytes, returning number of bytes written
  virtual FXival writeBlock(const void* data,FXival count);

  /// Truncate file
  virtual FXlong truncate(FXlong size);

  /// Flush to disk
  virtual bool flush();

  /// Test if we're at the end
  virtual bool eof();

  /// Return size of i/o device
  virtual FXlong size();

  /// Close handle
  virtual bool close();

  /// Destroy and close
  virtual ~FXIO();
  };

}

#endif