This file is indexed.

/usr/include/libwildmagic/Wm5BufferIO.h is in libwildmagic-dev 5.13-1+b2.

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
// Geometric Tools, LLC
// Copyright (c) 1998-2014
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.1 (2010/10/01)

#ifndef WM5BUFFERIO_H
#define WM5BUFFERIO_H

// Support for reading or writing a binary buffer.  If you open the buffer for
// reading, calling the writing routines is an error.  If you open the buffer
// for writing, calling the reading routines is an error.  This class does
// not support read-write access.  A common use for BufferIO is to read an
// entire file using FileIO::Load and then read the fields using BufferIO.
// Similarly, BufferIO may be used to write fields to a buffer followed by
// writing the entire file using FileIO::Save.
//
// The nested enumeration Mode supports endianness mismatches between the
// platform that created the file and the platform that is using it.  The
// flags are defined as follows:
//
// BM_READ
//   Read the data from the buffer as is (no byte swapping).
//
// BM_WRITE
//   Write the data to the buffer as is (no byte swapping).
//
// BM_READ_AND_SWAP
//   Read from the buffer and swap 2-, 4-, and 8-byte inputs.
//
// BM_WRITE_AND_SWAP
//   Write to the buffer and swap 2-, 4-, and 8-byte inputs.

#include "Wm5CoreLIB.h"

namespace Wm5
{

class WM5_CORE_ITEM BufferIO
{
public:
    enum
    {
        BM_NONE,
        BM_READ,
        BM_WRITE,
        BM_READ_AND_SWAP,
        BM_WRITE_AND_SWAP,

        // All data files are in little endian format, because most platforms
        // these days are little endian.  The BufferIO class is designed for a
        // block load of an entire file followed by parsing the buffer.
#ifdef WM5_LITTLE_ENDIAN
        BM_DEFAULT_READ = BM_READ,
        BM_DEFAULT_WRITE = BM_WRITE
#else
        BM_DEFAULT_READ = BM_READ_AND_SWAP,
        BM_DEFAULT_WRITE = BM_WRITE_AND_SWAP
#endif
    };

    // Construction and destruction.  The caller provides the memory for the
    // buffer, whether reading or writing, and is responsible for managing
    // that memory.  The buffer does not have to be dynamically allocated.
    // TODO:  Support writing where the total number of bytes to be written is
    // unknown.  This requires dynamic reallocation of the input buffer, and
    // accessors must be added, say, GetBuffer() and GetNumBytes().
    BufferIO ();
    BufferIO (int numBytesTotal, char* buffer, int mode);
    ~BufferIO ();

    bool Open (int numBytesTotal, char* buffer, int mode);
    bool Close ();

    // Implicit conversion to allow testing for successful construction.
    inline operator bool () const;

    // Member access.
    inline const char* GetBuffer () const;
    inline int GetNumBytesTotal () const;
    inline int GetNumBytesProcessed () const;
    inline int GetMode () const;
    bool IncrementNumBytesProcessed (int numBytes);

    // The return value is 'true' if and only if the operation was
    // successful, in which case the number of bytes read or written is
    // the item size times number of items.
    bool Read (size_t itemSize, void* datum);
    bool Read (size_t itemSize, int numItems, void* data);
    bool Write (size_t itemSize, const void* datum);
    bool Write (size_t itemSize, int numItems, const void* data);

private:
    char* mBuffer;
    int mNumBytesTotal;
    int mNumBytesProcessed;
    int mMode;
};

#include "Wm5BufferIO.inl"

}

#endif