This file is indexed.

/usr/include/simgear/misc/zfstream.hxx is in libsimgear-dev 3.0.0-1.

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
/**
 * \file zfstream.hxx
 * A C++ I/O streams interface to the zlib gz* functions.
 */

// Written by Bernie Bright, 1998
// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
//
// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 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
// Library General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//
// $Id$

#ifndef _zfstream_hxx
#define _zfstream_hxx

#include <simgear/compiler.h>

#include <zlib.h>


#include <streambuf>
#include <istream>

#define ios_openmode std::ios_base::openmode
#define ios_in       std::ios_base::in
#define ios_out      std::ios_base::out
#define ios_app      std::ios_base::app
#define ios_binary   std::ios_base::binary

#define ios_seekdir  std::ios_base::seekdir

#define ios_badbit   std::ios_base::badbit
#define ios_failbit  std::ios_base::failbit

/**
 * A C++ I/O streams interface to the zlib gz* functions.
 */
#ifdef SG_NEED_STREAMBUF_HACK
class gzfilebuf : public __streambuf {
    typedef __streambuf parent;
#else
class gzfilebuf : public std::streambuf {
    typedef std::streambuf parent;
#endif

public:
    /** Constructor */
    gzfilebuf();

    /** Destructor */
    virtual ~gzfilebuf();

    /**
     * Open a stream
     * @param name file name
     * @param io_mode mode flags
     * @return file stream
     */
    gzfilebuf* open( const char* name, ios_openmode io_mode );

    /** 
     * Attach to an existing file descriptor
     * @param file_descriptor file descriptor
     * @param io_mode mode flags
     * @return file stream
     */
    gzfilebuf* attach( int file_descriptor, ios_openmode io_mode );

    /** Close stream */
    gzfilebuf* close();

    int setcompressionlevel( int comp_level );
    int setcompressionstrategy( int comp_strategy );

    /** @return true if open, false otherwise */
    bool is_open() const { return (file != NULL); }

    /** @return stream position */
    virtual std::streampos seekoff( std::streamoff off, ios_seekdir way, ios_openmode which );

    /** sync the stream */
    virtual int sync();

protected:

    virtual int_type underflow();

    virtual int_type overflow( int_type c = parent::traits_type::eof() );
    bool    out_waiting();
    char*   base() {return obuffer;}
    int     blen() {return obuf_size;}
    char    allocate();

private:

    int_type flushbuf();
    int fillbuf();

    // Convert io_mode to "rwab" string.
    void cvt_iomode( char* mode_str, ios_openmode io_mode );

private:

    gzFile file;
    ios_openmode mode;
    bool own_file_descriptor;

    // Get (input) buffer.
    int ibuf_size;
    char* ibuffer;

    // Put (output) buffer.
    int obuf_size;
    char* obuffer;

    enum { page_size = 65536 };

private:
    // Not defined
    gzfilebuf( const gzfilebuf& );
    void operator= ( const gzfilebuf& );
};

/**
 * document me
 */
struct gzifstream_base
{
    gzifstream_base() {}

    gzfilebuf gzbuf;
};

/**
 * document me too
 */
struct gzofstream_base
{
    gzofstream_base() {}

    gzfilebuf gzbuf;
};

#endif // _zfstream_hxx