forked from mirror/openmw-tes3mp
Merge remote branch 'zini/master' into nif-cleanup
Conflicts: components/bsa/bsa_archive.cppactorid
Chris Robinson
13 years ago
commit
b4c8375f3c
@ -1,32 +0,0 @@
|
||||
#include "audiere_file.hpp"
|
||||
|
||||
using namespace audiere;
|
||||
using namespace Mangle::Stream;
|
||||
|
||||
bool AudiereFile::seek(int pos, SeekMode mode)
|
||||
{
|
||||
assert(inp->isSeekable);
|
||||
assert(inp->hasPosition);
|
||||
|
||||
size_t newPos;
|
||||
|
||||
switch(mode)
|
||||
{
|
||||
case BEGIN: newPos = pos; break;
|
||||
case CURRENT: newPos = pos+tell(); break;
|
||||
case END:
|
||||
// Seeking from the end. This requires that we're able to get
|
||||
// the entire size of the stream. The pos also has to be
|
||||
// non-positive.
|
||||
assert(inp->hasSize);
|
||||
assert(pos <= 0);
|
||||
newPos = inp->size() + pos;
|
||||
break;
|
||||
default:
|
||||
assert(0 && "invalid seek mode");
|
||||
}
|
||||
|
||||
inp->seek(newPos);
|
||||
return inp->tell() == newPos;
|
||||
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_AUDIERECLIENT_H
|
||||
#define MANGLE_STREAM_AUDIERECLIENT_H
|
||||
|
||||
#include <audiere.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "../stream.hpp"
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** @brief An Audiere::File that wraps a Mangle::Stream input.
|
||||
|
||||
This lets Audiere read sound files from any generic archive or
|
||||
file manager that supports Mangle streams.
|
||||
*/
|
||||
class AudiereFile : public audiere::RefImplementation<audiere::File>
|
||||
{
|
||||
StreamPtr inp;
|
||||
|
||||
public:
|
||||
AudiereFile(StreamPtr _inp)
|
||||
: inp(_inp) {}
|
||||
|
||||
/// Read 'count' bytes, return bytes successfully read
|
||||
int ADR_CALL read(void *buf, int count)
|
||||
{ return inp->read(buf,count); }
|
||||
|
||||
/// Seek, relative to specified seek mode. Returns true if successful.
|
||||
bool ADR_CALL seek(int pos, audiere::File::SeekMode mode);
|
||||
|
||||
/// Get current position
|
||||
int ADR_CALL tell()
|
||||
{ assert(inp->hasPosition); return inp->tell(); }
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,221 +0,0 @@
|
||||
#include "io_stream.hpp"
|
||||
|
||||
// This seems to work
|
||||
#ifndef EOF
|
||||
#define EOF -1
|
||||
#endif
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
|
||||
#define BSIZE 1024
|
||||
|
||||
// Streambuf for normal stream reading
|
||||
class _istreambuf : public std::streambuf
|
||||
{
|
||||
StreamPtr client;
|
||||
char buf[BSIZE];
|
||||
|
||||
public:
|
||||
_istreambuf(StreamPtr strm) : client(strm)
|
||||
{
|
||||
// Make sure we picked the right class
|
||||
assert(client->isReadable);
|
||||
assert(!client->hasPtr);
|
||||
|
||||
// Tell streambuf to delegate reading operations to underflow()
|
||||
setg(NULL,NULL,NULL);
|
||||
|
||||
// Disallow writing
|
||||
setp(NULL,NULL);
|
||||
}
|
||||
|
||||
/* Underflow is called when there is no more info to read in the
|
||||
input buffer. We need to refill buf with new data (if any), and
|
||||
set up the internal pointers with setg() to reflect the new
|
||||
state.
|
||||
*/
|
||||
int underflow()
|
||||
{
|
||||
// Read some more data
|
||||
size_t read = client->read(buf, BSIZE);
|
||||
assert(read <= BSIZE);
|
||||
|
||||
// If we're out of data, then EOF
|
||||
if(read == 0)
|
||||
return EOF;
|
||||
|
||||
// Otherwise, set up input buffer
|
||||
setg(buf, buf, buf+read);
|
||||
|
||||
// Return the first char
|
||||
return *((unsigned char*)buf);
|
||||
}
|
||||
|
||||
// Seek stream, if the source supports it. Ignores the second
|
||||
// parameter as Mangle doesn't separate input and output pointers.
|
||||
std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::in)
|
||||
{
|
||||
// Does this stream know how to seek?
|
||||
if(!client->isSeekable || !client->hasPosition)
|
||||
// If not, signal an error.
|
||||
return -1;
|
||||
|
||||
// Set stream position and reset the buffer.
|
||||
client->seek(pos);
|
||||
setg(NULL,NULL,NULL);
|
||||
|
||||
return client->tell();
|
||||
}
|
||||
};
|
||||
|
||||
// Streambuf optimized for pointer-based input streams
|
||||
class _ptrstreambuf : public std::streambuf
|
||||
{
|
||||
StreamPtr client;
|
||||
|
||||
public:
|
||||
_ptrstreambuf(StreamPtr strm) : client(strm)
|
||||
{
|
||||
// Make sure we picked the right class
|
||||
assert(client->isReadable);
|
||||
assert(client->hasPtr);
|
||||
|
||||
// seekpos() does all the work
|
||||
seekpos(0);
|
||||
}
|
||||
|
||||
// Underflow is only called when we're at the end of the file
|
||||
int underflow() { return EOF; }
|
||||
|
||||
// Seek to a new position within the memory stream. This bypasses
|
||||
// client->seek() entirely so isSeekable doesn't have to be set.
|
||||
std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::in)
|
||||
{
|
||||
// All pointer streams need a size
|
||||
assert(client->hasSize);
|
||||
|
||||
// Figure out how much will be left of the stream after seeking
|
||||
size_t size = client->size() - pos;
|
||||
|
||||
// Get a pointer
|
||||
char* ptr = (char*)client->getPtr(pos,size);
|
||||
|
||||
// And use it
|
||||
setg(ptr,ptr,ptr+size);
|
||||
|
||||
return pos;
|
||||
}
|
||||
};
|
||||
|
||||
// Streambuf for stream writing
|
||||
class _ostreambuf : public std::streambuf
|
||||
{
|
||||
StreamPtr client;
|
||||
char buf[BSIZE];
|
||||
|
||||
public:
|
||||
_ostreambuf(StreamPtr strm) : client(strm)
|
||||
{
|
||||
// Make sure we picked the right class
|
||||
assert(client->isWritable);
|
||||
|
||||
// Inform streambuf about our nice buffer
|
||||
setp(buf, buf+BSIZE);
|
||||
|
||||
// Disallow reading
|
||||
setg(NULL,NULL,NULL);
|
||||
}
|
||||
|
||||
/* Sync means to flush (write) all current data to the output
|
||||
stream. It will also set up the entire output buffer to be usable
|
||||
again.
|
||||
*/
|
||||
int sync()
|
||||
{
|
||||
// Get the number of bytes that streambuf wants us to write
|
||||
int num = pptr() - pbase();
|
||||
assert(num >= 0);
|
||||
|
||||
// Is there any work to do?
|
||||
if(num == 0) return 0;
|
||||
|
||||
if((int)client->write(pbase(), num) != num)
|
||||
// Inform caller that writing failed
|
||||
return -1;
|
||||
|
||||
// Reset output buffer pointers
|
||||
setp(buf, buf+BSIZE);
|
||||
|
||||
// No error
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called whenever the output buffer is full.
|
||||
*/
|
||||
int overflow(int c)
|
||||
{
|
||||
// First, write all existing data
|
||||
if(sync()) return EOF;
|
||||
|
||||
// Put the requested character in the next round of output
|
||||
if(c != EOF)
|
||||
{
|
||||
*pptr() = c;
|
||||
pbump(1);
|
||||
}
|
||||
|
||||
// No error
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Seek stream, if the source supports it.
|
||||
std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::out)
|
||||
{
|
||||
if(!client->isSeekable || !client->hasPosition)
|
||||
return -1;
|
||||
|
||||
// Flush data and reset buffers
|
||||
sync();
|
||||
|
||||
// Set stream position
|
||||
client->seek(pos);
|
||||
|
||||
return client->tell();
|
||||
}
|
||||
};
|
||||
|
||||
MangleIStream::MangleIStream(StreamPtr inp)
|
||||
: std::istream(NULL)
|
||||
{
|
||||
assert(inp->isReadable);
|
||||
|
||||
// Pick the right streambuf implementation based on whether the
|
||||
// input supports pointers or not.
|
||||
if(inp->hasPtr)
|
||||
buf = new _ptrstreambuf(inp);
|
||||
else
|
||||
buf = new _istreambuf(inp);
|
||||
|
||||
rdbuf(buf);
|
||||
}
|
||||
|
||||
MangleIStream::~MangleIStream()
|
||||
{
|
||||
delete buf;
|
||||
}
|
||||
|
||||
MangleOStream::MangleOStream(StreamPtr out)
|
||||
: std::ostream(NULL)
|
||||
{
|
||||
assert(out->isWritable);
|
||||
buf = new _ostreambuf(out);
|
||||
|
||||
rdbuf(buf);
|
||||
}
|
||||
|
||||
MangleOStream::~MangleOStream()
|
||||
{
|
||||
// Make sure we don't have lingering data on exit
|
||||
flush();
|
||||
delete buf;
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_IOSTREAM_H
|
||||
#define MANGLE_STREAM_IOSTREAM_H
|
||||
|
||||
#include <assert.h>
|
||||
#include "../stream.hpp"
|
||||
#include <iostream>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** This file contains classes for wrapping an std::istream or
|
||||
std::ostream around a Mangle::Stream.
|
||||
|
||||
This allows you to use Mangle streams in places that require std
|
||||
streams.
|
||||
|
||||
This is much easier than trying to make your own custom streams
|
||||
into iostreams. The std::iostream interface is horrible and NOT
|
||||
designed for easy subclassing. Create a Mangle::Stream instead,
|
||||
and use this wrapper.
|
||||
*/
|
||||
|
||||
// An istream wrapping a readable Mangle::Stream. Has extra
|
||||
// optimizations for pointer-based streams.
|
||||
class MangleIStream : public std::istream
|
||||
{
|
||||
std::streambuf *buf;
|
||||
public:
|
||||
MangleIStream(StreamPtr inp);
|
||||
~MangleIStream();
|
||||
};
|
||||
|
||||
// An ostream wrapping a writable Mangle::Stream.
|
||||
class MangleOStream : public std::ostream
|
||||
{
|
||||
std::streambuf *buf;
|
||||
public:
|
||||
MangleOStream(StreamPtr inp);
|
||||
~MangleOStream();
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,68 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_OGRECLIENT_H
|
||||
#define MANGLE_STREAM_OGRECLIENT_H
|
||||
|
||||
#include <OgreDataStream.h>
|
||||
#include <assert.h>
|
||||
#include "../stream.hpp"
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** An OGRE DataStream that wraps a Mangle::Stream input.
|
||||
|
||||
This has been built and tested against OGRE 1.6.2. You might have
|
||||
to make your own modifications if you're working with newer (or
|
||||
older) versions.
|
||||
*/
|
||||
class Mangle2OgreStream : public Ogre::DataStream
|
||||
{
|
||||
StreamPtr inp;
|
||||
|
||||
void init()
|
||||
{
|
||||
// Get the size, if possible
|
||||
if(inp->hasSize)
|
||||
mSize = inp->size();
|
||||
|
||||
// Allow writing if inp supports it
|
||||
if(inp->isWritable)
|
||||
mAccess |= Ogre::DataStream::WRITE;
|
||||
}
|
||||
|
||||
public:
|
||||
/// Constructor without name
|
||||
Mangle2OgreStream(StreamPtr _inp)
|
||||
: inp(_inp) { init(); }
|
||||
|
||||
/// Constructor for a named data stream
|
||||
Mangle2OgreStream(const Ogre::String &name, StreamPtr _inp)
|
||||
: Ogre::DataStream(name), inp(_inp) { init(); }
|
||||
|
||||
// Only implement the DataStream functions we have to implement
|
||||
|
||||
size_t read(void *buf, size_t count)
|
||||
{ return inp->read(buf,count); }
|
||||
|
||||
size_t write(const void *buf, size_t count)
|
||||
{ assert(inp->isWritable); return inp->write(buf,count); }
|
||||
|
||||
void skip(long count)
|
||||
{
|
||||
assert(inp->isSeekable && inp->hasPosition);
|
||||
inp->seek(inp->tell() + count);
|
||||
}
|
||||
|
||||
void seek(size_t pos)
|
||||
{ assert(inp->isSeekable); inp->seek(pos); }
|
||||
|
||||
size_t tell() const
|
||||
{ assert(inp->hasPosition); return inp->tell(); }
|
||||
|
||||
bool eof() const { return inp->eof(); }
|
||||
|
||||
/// Does nothing
|
||||
void close() {}
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,74 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_BUFFER_H
|
||||
#define MANGLE_STREAM_BUFFER_H
|
||||
|
||||
#include "../servers/memory_stream.hpp"
|
||||
#include <vector>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** A Stream that reads another Stream into a buffer, and serves it as
|
||||
a MemoryStream. Might be expanded with other capabilities later.
|
||||
*/
|
||||
|
||||
class BufferStream : public MemoryStream
|
||||
{
|
||||
std::vector<char> buffer;
|
||||
|
||||
public:
|
||||
/*
|
||||
input = stream to copy
|
||||
ADD = each read increment (for streams without size())
|
||||
*/
|
||||
BufferStream(StreamPtr input, size_t ADD = 32*1024)
|
||||
{
|
||||
assert(input);
|
||||
|
||||
// Allocate memory, read the stream into it. Then call set()
|
||||
if(input->hasSize)
|
||||
{
|
||||
// We assume that we can get the position as well
|
||||
assert(input->hasPosition);
|
||||
|
||||
// Calculate how much is left of the stream
|
||||
size_t left = input->size() - input->tell();
|
||||
|
||||
// Allocate the buffer and fill it
|
||||
buffer.resize(left);
|
||||
input->read(&buffer[0], left);
|
||||
}
|
||||
else
|
||||
{
|
||||
// We DON'T know how big the stream is. We'll have to read
|
||||
// it in increments.
|
||||
size_t len=0, newlen;
|
||||
|
||||
while(!input->eof())
|
||||
{
|
||||
// Read one block
|
||||
newlen = len + ADD;
|
||||
buffer.resize(newlen);
|
||||
size_t read = input->read(&buffer[len], ADD);
|
||||
|
||||
// Increase the total length
|
||||
len += read;
|
||||
|
||||
// If we read less than expected, we should be at the
|
||||
// end of the stream
|
||||
assert(read == ADD || (read < ADD && input->eof()));
|
||||
}
|
||||
|
||||
// Downsize to match the real length
|
||||
buffer.resize(len);
|
||||
}
|
||||
|
||||
// After the buffer has been filled, set up our MemoryStream
|
||||
// ancestor to reference it.
|
||||
set(&buffer[0], buffer.size());
|
||||
}
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<BufferStream> BufferStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,46 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_FILTER_H
|
||||
#define MANGLE_STREAM_FILTER_H
|
||||
|
||||
#include "../stream.hpp"
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** A stream that filters another stream with no changes. Intended as
|
||||
a base class for other filters.
|
||||
*/
|
||||
class PureFilter : public Stream
|
||||
{
|
||||
protected:
|
||||
StreamPtr src;
|
||||
|
||||
public:
|
||||
PureFilter() {}
|
||||
PureFilter(StreamPtr _src)
|
||||
{ setStream(_src); }
|
||||
|
||||
void setStream(StreamPtr _src)
|
||||
{
|
||||
src = _src;
|
||||
isSeekable = src->isSeekable;
|
||||
isWritable = src->isWritable;
|
||||
hasPosition = src->hasPosition;
|
||||
hasSize = src->hasSize;
|
||||
hasPtr = src->hasPtr;
|
||||
}
|
||||
|
||||
size_t read(void *buf, size_t count) { return src->read(buf, count); }
|
||||
size_t write(const void *buf, size_t count) { return src->write(buf,count); }
|
||||
void flush() { src->flush(); }
|
||||
void seek(size_t pos) { src->seek(pos); }
|
||||
size_t tell() const { return src->tell(); }
|
||||
size_t size() const { return src->size(); }
|
||||
bool eof() const { return src->eof(); }
|
||||
const void *getPtr() { return src->getPtr(); }
|
||||
const void *getPtr(size_t size) { return src->getPtr(size); }
|
||||
const void *getPtr(size_t pos, size_t size)
|
||||
{ return src->getPtr(pos, size); }
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,101 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_SLICE_H
|
||||
#define MANGLE_STREAM_SLICE_H
|
||||
|
||||
#include "../stream.hpp"
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** A Stream that represents a subset (called a slice) of another stream.
|
||||
*/
|
||||
class SliceStream : public Stream
|
||||
{
|
||||
StreamPtr src;
|
||||
size_t offset, length, pos;
|
||||
|
||||
public:
|
||||
SliceStream(StreamPtr _src, size_t _offset, size_t _length)
|
||||
: src(_src), offset(_offset), length(_length), pos(0)
|
||||
{
|
||||
assert(src->hasSize);
|
||||
assert(src->isSeekable);
|
||||
|
||||
// Make sure we can actually fit inside the source stream
|
||||
assert(src->size() >= offset+length);
|
||||
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
hasPtr = src->hasPtr;
|
||||
isWritable = src->isWritable;
|
||||
}
|
||||
|
||||
size_t read(void *buf, size_t count)
|
||||
{
|
||||
// Check that we're not reading past our slice
|
||||
if(count > length-pos)
|
||||
count = length-pos;
|
||||
|
||||
// Seek into place and start reading
|
||||
src->seek(offset+pos);
|
||||
count = src->read(buf, count);
|
||||
|
||||
pos += count;
|
||||
assert(pos <= length);
|
||||
return count;
|
||||
}
|
||||
|
||||
// Note that writing to a slice does not allow you to append data,
|
||||
// you may only overwrite existing data.
|
||||
size_t write(const void *buf, size_t count)
|
||||
{
|
||||
assert(isWritable);
|
||||
// Check that we're not reading past our slice
|
||||
if(count > length-pos)
|
||||
count = length-pos;
|
||||
|
||||
// Seek into place and action
|
||||
src->seek(offset+pos);
|
||||
count = src->write(buf, count);
|
||||
|
||||
pos += count;
|
||||
assert(pos <= length);
|
||||
return count;
|
||||
}
|
||||
|
||||
void seek(size_t _pos)
|
||||
{
|
||||
pos = _pos;
|
||||
if(pos > length) pos = length;
|
||||
}
|
||||
|
||||
bool eof() const { return pos == length; }
|
||||
size_t tell() const { return pos; }
|
||||
size_t size() const { return length; }
|
||||
void flush() { src->flush(); }
|
||||
|
||||
const void *getPtr() { return getPtr(0, length); }
|
||||
const void *getPtr(size_t size)
|
||||
{
|
||||
const void *ptr = getPtr(pos, size);
|
||||
seek(pos+size);
|
||||
return ptr;
|
||||
}
|
||||
const void *getPtr(size_t pos, size_t size)
|
||||
{
|
||||
// Boundry checks on pos and size. Bounding the size is
|
||||
// important even when getting pointers, as the source stream
|
||||
// may use the size parameter for something (such as memory
|
||||
// mapping or buffering.)
|
||||
if(pos > length) pos = length;
|
||||
if(pos+size > length) size = length-pos;
|
||||
|
||||
// Ask the source to kindly give us a pointer
|
||||
return src->getPtr(offset+pos, size);
|
||||
}
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<SliceStream> SliceStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,32 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_FILESERVER_H
|
||||
#define MANGLE_STREAM_FILESERVER_H
|
||||
|
||||
#include "std_stream.hpp"
|
||||
#include <fstream>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** Very simple file input stream, based on std::ifstream
|
||||
*/
|
||||
class FileStream : public StdStream
|
||||
{
|
||||
std::ifstream file;
|
||||
|
||||
public:
|
||||
FileStream(const std::string &name)
|
||||
: StdStream(&file)
|
||||
{
|
||||
file.open(name.c_str(), std::ios::binary);
|
||||
|
||||
if(file.fail())
|
||||
throw std::runtime_error("FileStream: failed to open file " + name);
|
||||
}
|
||||
~FileStream() { file.close(); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<FileStream> FileStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,116 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_MEMSERVER_H
|
||||
#define MANGLE_STREAM_MEMSERVER_H
|
||||
|
||||
#include <assert.h>
|
||||
#include "../stream.hpp"
|
||||
#include <string.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
// Do this before the class declaration, since the class itself
|
||||
// uses it.
|
||||
class MemoryStream;
|
||||
typedef boost::shared_ptr<MemoryStream> MemoryStreamPtr;
|
||||
|
||||
/** A Stream wrapping a memory buffer
|
||||
|
||||
This will create a fully seekable stream out of any pointer/length
|
||||
pair you give it.
|
||||
*/
|
||||
class MemoryStream : public Stream
|
||||
{
|
||||
const void *data;
|
||||
size_t length, pos;
|
||||
|
||||
public:
|
||||
MemoryStream(const void *ptr, size_t len)
|
||||
: data(ptr), length(len), pos(0)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
hasPtr = true;
|
||||
}
|
||||
|
||||
MemoryStream()
|
||||
: data(NULL), length(0), pos(0)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
hasPtr = true;
|
||||
}
|
||||
|
||||
size_t read(void *buf, size_t count)
|
||||
{
|
||||
assert(data != NULL);
|
||||
assert(pos <= length);
|
||||
|
||||
// Don't read more than we have
|
||||
if(count > (length - pos))
|
||||
count = length - pos;
|
||||
|
||||
// Copy data
|
||||
if(count)
|
||||
memcpy(buf, ((char*)data)+pos, count);
|
||||
|
||||
// aaand remember to increase the count
|
||||
pos += count;
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
void seek(size_t _pos)
|
||||
{
|
||||
pos = _pos;
|
||||
if(pos > length)
|
||||
pos = length;
|
||||
}
|
||||
|
||||
size_t tell() const { return pos; }
|
||||
size_t size() const { return length; }
|
||||
bool eof() const { return pos == length; }
|
||||
|
||||
const void *getPtr() { return data; }
|
||||
const void *getPtr(size_t size)
|
||||
{
|
||||
// This variant of getPtr must move the position pointer
|
||||
size_t opos = pos;
|
||||
pos += size;
|
||||
if(pos > length) pos = length;
|
||||
return ((char*)data)+opos;
|
||||
}
|
||||
const void *getPtr(size_t pos, size_t size)
|
||||
{
|
||||
if(pos > length) pos = length;
|
||||
return ((char*)data)+pos;
|
||||
}
|
||||
|
||||
// New members in MemoryStream:
|
||||
|
||||
/// Set a new buffer and length. This will rewind the position to zero.
|
||||
void set(const void* _data, size_t _length)
|
||||
{
|
||||
data = _data;
|
||||
length = _length;
|
||||
pos = 0;
|
||||
}
|
||||
|
||||
/// Clone this memory stream
|
||||
/** Make a new stream of the same buffer. If setPos is true, we also
|
||||
set the clone's position to be the same as ours.
|
||||
|
||||
No memory is copied during this operation, the new stream is
|
||||
just another 'view' into the same shared memory buffer.
|
||||
*/
|
||||
MemoryStreamPtr clone(bool setPos=false) const
|
||||
{
|
||||
MemoryStreamPtr res(new MemoryStream(data, length));
|
||||
if(setPos) res->seek(pos);
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,37 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_OGRESERVER_H
|
||||
#define MANGLE_STREAM_OGRESERVER_H
|
||||
|
||||
#include <OgreDataStream.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** A Stream wrapping an OGRE DataStream.
|
||||
|
||||
This has been built and tested against OGRE 1.6.2. You might have
|
||||
to make your own modifications if you're working with newer (or
|
||||
older) versions.
|
||||
*/
|
||||
class OgreStream : public Stream
|
||||
{
|
||||
Ogre::DataStreamPtr inp;
|
||||
|
||||
public:
|
||||
OgreStream(Ogre::DataStreamPtr _inp) : inp(_inp)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
}
|
||||
|
||||
size_t read(void *buf, size_t count) { return inp->read(buf,count); }
|
||||
void seek(size_t pos) { inp->seek(pos); }
|
||||
size_t tell() const { return inp->tell(); }
|
||||
size_t size() const { return inp->size(); }
|
||||
bool eof() const { return inp->eof(); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<OgreStream> OgreStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,41 +0,0 @@
|
||||
#ifndef MANGLE_OSTREAM_FILESERVER_H
|
||||
#define MANGLE_OSTREAM_FILESERVER_H
|
||||
|
||||
#include "std_ostream.hpp"
|
||||
#include <fstream>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** File stream based on std::ofstream, only supports writing.
|
||||
*/
|
||||
class OutFileStream : public StdOStream
|
||||
{
|
||||
std::ofstream file;
|
||||
|
||||
public:
|
||||
/**
|
||||
By default we overwrite the file. If append=true, then we will
|
||||
open an existing file and seek to the end instead.
|
||||
*/
|
||||
OutFileStream(const std::string &name, bool append=false)
|
||||
: StdOStream(&file)
|
||||
{
|
||||
std::ios::openmode mode = std::ios::binary;
|
||||
if(append)
|
||||
mode |= std::ios::app;
|
||||
else
|
||||
mode |= std::ios::trunc;
|
||||
|
||||
file.open(name.c_str(), mode);
|
||||
|
||||
if(file.fail())
|
||||
throw std::runtime_error("OutFileStream: failed to open file " + name);
|
||||
}
|
||||
~OutFileStream() { file.close(); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<OutFileStream> OutFileStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,36 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_OGRESERVER_H
|
||||
#define MANGLE_STREAM_OGRESERVER_H
|
||||
|
||||
#include <physfs.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/// A Stream wrapping a PHYSFS_file stream from the PhysFS library.
|
||||
class PhysFile : public Stream
|
||||
{
|
||||
PHYSFS_file *file;
|
||||
|
||||
public:
|
||||
PhysFile(PHYSFS_file *inp) : file(inp)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
}
|
||||
|
||||
~PhysFile() { PHYSFS_close(file); }
|
||||
|
||||
size_t read(void *buf, size_t count)
|
||||
{ return PHYSFS_read(file, buf, 1, count); }
|
||||
|
||||
void seek(size_t pos) { PHYSFS_seek(file, pos); }
|
||||
size_t tell() const { return PHYSFS_tell(file); }
|
||||
size_t size() const { return PHYSFS_fileLength(file); }
|
||||
bool eof() const { return PHYSFS_eof(file); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<PhysFile> PhysFilePtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,78 +0,0 @@
|
||||
#ifndef MANGLE_OSTREAM_STDIOSERVER_H
|
||||
#define MANGLE_OSTREAM_STDIOSERVER_H
|
||||
|
||||
#include "../stream.hpp"
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** Simple wrapper for std::ostream, only supports output.
|
||||
*/
|
||||
class StdOStream : public Stream
|
||||
{
|
||||
std::ostream *inf;
|
||||
|
||||
static void fail(const std::string &msg)
|
||||
{ throw std::runtime_error("StdOStream: " + msg); }
|
||||
|
||||
public:
|
||||
StdOStream(std::ostream *_inf)
|
||||
: inf(_inf)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
isWritable = true;
|
||||
isReadable = false;
|
||||
}
|
||||
|
||||
size_t write(const void* buf, size_t len)
|
||||
{
|
||||
inf->write((const char*)buf, len);
|
||||
if(inf->fail())
|
||||
fail("error writing to stream");
|
||||
// Just return len, but that is ok. The only cases where we would
|
||||
// return less than len is when an error occured.
|
||||
return len;
|
||||
}
|
||||
|
||||
void flush()
|
||||
{
|
||||
inf->flush();
|
||||
}
|
||||
|
||||
void seek(size_t pos)
|
||||
{
|
||||
inf->seekp(pos);
|
||||
if(inf->fail())
|
||||
fail("seek error");
|
||||
}
|
||||
|
||||
size_t tell() const
|
||||
// Hack around the fact that ifstream->tellp() isn't const
|
||||
{ return ((StdOStream*)this)->inf->tellp(); }
|
||||
|
||||
size_t size() const
|
||||
{
|
||||
// Use the standard iostream size hack, terrible as it is.
|
||||
std::streampos pos = inf->tellp();
|
||||
inf->seekp(0, std::ios::end);
|
||||
size_t res = inf->tellp();
|
||||
inf->seekp(pos);
|
||||
|
||||
if(inf->fail())
|
||||
fail("could not get stream size");
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
bool eof() const
|
||||
{ return inf->eof(); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<StdOStream> StdOStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,70 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_STDIOSERVER_H
|
||||
#define MANGLE_STREAM_STDIOSERVER_H
|
||||
|
||||
#include "../stream.hpp"
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/** Simple wrapper for std::istream.
|
||||
*/
|
||||
class StdStream : public Stream
|
||||
{
|
||||
std::istream *inf;
|
||||
|
||||
static void fail(const std::string &msg)
|
||||
{ throw std::runtime_error("StdStream: " + msg); }
|
||||
|
||||
public:
|
||||
StdStream(std::istream *_inf)
|
||||
: inf(_inf)
|
||||
{
|
||||
isSeekable = true;
|
||||
hasPosition = true;
|
||||
hasSize = true;
|
||||
}
|
||||
|
||||
size_t read(void* buf, size_t len)
|
||||
{
|
||||
inf->read((char*)buf, len);
|
||||
if(inf->bad())
|
||||
fail("error reading from stream");
|
||||
return inf->gcount();
|
||||
}
|
||||
|
||||
void seek(size_t pos)
|
||||
{
|
||||
inf->clear();
|
||||
inf->seekg(pos);
|
||||
if(inf->fail())
|
||||
fail("seek error");
|
||||
}
|
||||
|
||||
size_t tell() const
|
||||
// Hack around the fact that ifstream->tellg() isn't const
|
||||
{ return ((StdStream*)this)->inf->tellg(); }
|
||||
|
||||
size_t size() const
|
||||
{
|
||||
// Use the standard iostream size hack, terrible as it is.
|
||||
std::streampos pos = inf->tellg();
|
||||
inf->seekg(0, std::ios::end);
|
||||
size_t res = inf->tellg();
|
||||
inf->seekg(pos);
|
||||
|
||||
if(inf->fail())
|
||||
fail("could not get stream size");
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
bool eof() const
|
||||
{ return inf->eof(); }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<StdStream> StdStreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,103 +0,0 @@
|
||||
#ifndef MANGLE_STREAM_INPUT_H
|
||||
#define MANGLE_STREAM_INPUT_H
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "../tools/shared_ptr.hpp"
|
||||
#include <assert.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace Stream {
|
||||
|
||||
/// An abstract interface for a stream data.
|
||||
class Stream
|
||||
{
|
||||
public:
|
||||
// Feature options. These should be set in the constructor.
|
||||
|
||||
/// If true, seek() works
|
||||
bool isSeekable;
|
||||
|
||||
/// If true, tell() works
|
||||
bool hasPosition;
|
||||
|
||||
/// If true, size() works
|
||||
bool hasSize;
|
||||
|
||||
/// If true, write() works. Writing through pointer operations is
|
||||
/// not (yet) supported.
|
||||
bool isWritable;
|
||||
|
||||
/// If true, read() and eof() works.
|
||||
bool isReadable;
|
||||
|
||||
/// If true, the getPtr() functions work
|
||||
bool hasPtr;
|
||||
|
||||
/// Initialize all bools to false by default, except isReadable.
|
||||
Stream() :
|
||||
isSeekable(false), hasPosition(false), hasSize(false),
|
||||
isWritable(false), isReadable(true), hasPtr(false) {}
|
||||
|
||||
/// Virtual destructor
|
||||
virtual ~Stream() {}
|
||||
|
||||
/** Read a given number of bytes from the stream. Returns the actual
|
||||
number read. If the return value is less than count, then the
|
||||
stream is empty or an error occured. Only required for readable
|
||||
streams.
|
||||
*/
|
||||
virtual size_t read(void* buf, size_t count) { assert(0); return 0; }
|
||||
|
||||
/** Write a given number of bytes from the stream. Semantics is
|
||||
similar to read(). Only valid if isWritable is true.
|
||||
|
||||
The returned value is the number of bytes written. However in
|
||||
most cases, unlike for read(), a write-count less than requested
|
||||
usually indicates an error. The implementation should throw such
|
||||
errors as exceptions rather than expect the caller to handle
|
||||
them.
|
||||
|
||||
Since most implementations do NOT support writing we default to
|
||||
an assert(0) here.
|
||||
*/
|
||||
virtual size_t write(const void *buf, size_t count) { assert(0); return 0; }
|
||||
|
||||
/// Flush an output stream. Does nothing for non-writing streams.
|
||||
virtual void flush() {}
|
||||
|
||||
/// Seek to an absolute position in this stream. Not all streams are
|
||||
/// seekable.
|
||||
virtual void seek(size_t pos) { assert(0); }
|
||||
|
||||
/// Get the current position in the stream. Non-seekable streams are
|
||||
/// not required to keep track of this.
|
||||
virtual size_t tell() const { assert(0); return 0; }
|
||||
|
||||
/// Return the total size of the stream. For streams hasSize is
|
||||
/// false, size() should fail in some way, since it is an error to
|
||||
/// call it in those cases.
|
||||
virtual size_t size() const { assert(0); return 0; }
|
||||
|
||||
/// Returns true if the stream is empty. Required for readable
|
||||
/// streams.
|
||||
virtual bool eof() const { assert(0); return 0; }
|
||||
|
||||
/// Return a pointer to the entire stream. This function (and the
|
||||
/// other getPtr() variants below) should only be implemented for
|
||||
/// memory-based streams where using them would be an optimization.
|
||||
virtual const void *getPtr() { assert(0); return NULL; }
|
||||
|
||||
/// Get a pointer to a memory region of 'size' bytes starting from
|
||||
/// position 'pos'
|
||||
virtual const void *getPtr(size_t pos, size_t size) { assert(0); return NULL; }
|
||||
|
||||
/// Get a pointer to a memory region of 'size' bytes from the
|
||||
/// current position. Unlike the two other getPtr variants, this
|
||||
/// will advance the position past the returned area.
|
||||
virtual const void *getPtr(size_t size) { assert(0); return NULL; }
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<Stream> StreamPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,2 +0,0 @@
|
||||
*_test
|
||||
test.file
|
||||
@ -1,34 +0,0 @@
|
||||
GCC=g++ -I../ -Wall -Werror
|
||||
|
||||
all: ogre_client_test audiere_client_test memory_server_test buffer_filter_test file_server_test slice_filter_test file_write_test iostream_test
|
||||
|
||||
I_OGRE=$(shell pkg-config --cflags OGRE)
|
||||
L_OGRE=$(shell pkg-config --libs OGRE)
|
||||
L_AUDIERE=-laudiere
|
||||
|
||||
ogre_client_test: ogre_client_test.cpp ../stream.hpp ../clients/ogre_datastream.hpp
|
||||
$(GCC) $< -o $@ $(I_OGRE) $(L_OGRE)
|
||||
|
||||
audiere_client_test: audiere_client_test.cpp ../stream.hpp ../clients/audiere_file.hpp ../clients/audiere_file.cpp
|
||||
$(GCC) $< -o $@ ../clients/audiere_file.cpp $(L_AUDIERE)
|
||||
|
||||
iostream_test: iostream_test.cpp ../clients/io_stream.cpp
|
||||
$(GCC) $^ -o $@
|
||||
|
||||
file_server_test: file_server_test.cpp ../stream.hpp ../servers/file_stream.hpp ../servers/std_stream.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
file_write_test: file_write_test.cpp ../stream.hpp ../servers/outfile_stream.hpp ../servers/std_ostream.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
memory_server_test: memory_server_test.cpp ../stream.hpp ../servers/memory_stream.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
buffer_filter_test: buffer_filter_test.cpp ../stream.hpp ../servers/memory_stream.hpp ../filters/buffer_stream.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
slice_filter_test: slice_filter_test.cpp ../stream.hpp ../servers/memory_stream.hpp ../filters/slice_stream.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
clean:
|
||||
rm *_test
|
||||
@ -1,34 +0,0 @@
|
||||
#include "../servers/memory_stream.hpp"
|
||||
#include "../clients/audiere_file.hpp"
|
||||
#include <audiere.h>
|
||||
#include <iostream>
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace audiere;
|
||||
using namespace std;
|
||||
|
||||
int main()
|
||||
{
|
||||
char str[12];
|
||||
memset(str, 0, 12);
|
||||
StreamPtr inp(new MemoryStream("hello world", 11));
|
||||
FilePtr p(new AudiereFile(inp));
|
||||
cout << "pos=" << p->tell() << endl;
|
||||
p->read(str, 2);
|
||||
cout << "2 bytes: " << str << endl;
|
||||
cout << "pos=" << p->tell() << endl;
|
||||
p->seek(4, File::BEGIN);
|
||||
cout << "pos=" << p->tell() << endl;
|
||||
p->read(str, 3);
|
||||
cout << "3 bytes: " << str << endl;
|
||||
p->seek(-1, File::CURRENT);
|
||||
cout << "pos=" << p->tell() << endl;
|
||||
p->seek(-4, File::END);
|
||||
cout << "pos=" << p->tell() << endl;
|
||||
p->read(str, 4);
|
||||
cout << "last 4 bytes: " << str << endl;
|
||||
p->seek(0, File::BEGIN);
|
||||
p->read(str, 11);
|
||||
cout << "entire stream: " << str << endl;
|
||||
return 0;
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
|
||||
#include "../filters/buffer_stream.hpp"
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
int main()
|
||||
{
|
||||
StreamPtr orig (new MemoryStream("hello world", 11));
|
||||
StreamPtr inp (new BufferStream(orig));
|
||||
|
||||
cout << "Size: " << inp->size() << endl;
|
||||
cout << "Pos: " << inp->tell() << "\nSeeking...\n";
|
||||
inp->seek(3);
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
char data[12];
|
||||
memset(data, 0, 12);
|
||||
cout << "Reading: " << inp->read(data, 4) << endl;
|
||||
cout << "Four bytes: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << "\nSeeking again...\n";
|
||||
inp->seek(33);
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Eof: " << inp->eof() << "\nSeek to 6\n";
|
||||
inp->seek(6);
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Over-reading: " << inp->read(data, 200) << endl;
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
inp->seek(0);
|
||||
cout << "Finally, reading the entire string: " << inp->read(data,11) << endl;
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
#include "../servers/file_stream.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
int main()
|
||||
{
|
||||
StreamPtr inp(new FileStream("file_server_test.cpp"));
|
||||
|
||||
char buf[21];
|
||||
buf[20] = 0;
|
||||
cout << "pos=" << inp->tell() << " eof=" << inp->eof() << endl;
|
||||
inp->read(buf, 20);
|
||||
cout << "First 20 bytes: " << buf << endl;
|
||||
cout << "pos=" << inp->tell() << " eof=" << inp->eof() << endl;
|
||||
return 0;
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
#include "../servers/outfile_stream.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
void print(Stream &str)
|
||||
{
|
||||
cout << "size=" << str.size()
|
||||
<< " pos=" << str.tell()
|
||||
<< " eof=" << str.eof()
|
||||
<< endl;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
cout << "\nCreating file\n";
|
||||
OutFileStream out("test.file");
|
||||
print(out);
|
||||
out.write("hello",5);
|
||||
print(out);
|
||||
}
|
||||
|
||||
{
|
||||
cout << "\nAppending to file\n";
|
||||
OutFileStream out("test.file", true);
|
||||
print(out);
|
||||
out.write(" again\n",7);
|
||||
print(out);
|
||||
}
|
||||
|
||||
{
|
||||
cout << "\nOverwriting file\n";
|
||||
OutFileStream out("test.file");
|
||||
print(out);
|
||||
out.write("overwrite!\n",11);
|
||||
print(out);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -1,176 +0,0 @@
|
||||
#include <iostream>
|
||||
#include "../clients/io_stream.hpp"
|
||||
#include "../servers/memory_stream.hpp"
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
void test1()
|
||||
{
|
||||
cout << "Testing ASCII reading from memory:\n";
|
||||
StreamPtr input(new MemoryStream("hello you world you", 19));
|
||||
MangleIStream inp(input);
|
||||
|
||||
string str;
|
||||
while(!inp.eof())
|
||||
{
|
||||
inp >> str;
|
||||
cout << "Got: " << str << endl;
|
||||
}
|
||||
}
|
||||
|
||||
class Dummy : public Stream
|
||||
{
|
||||
int count;
|
||||
|
||||
public:
|
||||
|
||||
Dummy() : count(0)
|
||||
{
|
||||
}
|
||||
|
||||
size_t read(void *ptr, size_t num)
|
||||
{
|
||||
char *p = (char*)ptr;
|
||||
char *start = p;
|
||||
for(; (count < 2560) && (p-start < (int)num); count++)
|
||||
{
|
||||
*p = count / 10;
|
||||
p++;
|
||||
}
|
||||
return p-start;
|
||||
}
|
||||
|
||||
bool eof() const { return count == 2560; }
|
||||
};
|
||||
|
||||
void test2()
|
||||
{
|
||||
cout << "\nTesting binary reading from non-memory:\n";
|
||||
|
||||
StreamPtr input(new Dummy);
|
||||
MangleIStream inp(input);
|
||||
|
||||
int x = 0;
|
||||
while(!inp.eof())
|
||||
{
|
||||
unsigned char buf[5];
|
||||
inp.read((char*)buf,5);
|
||||
|
||||
// istream doesn't set eof() until we read _beyond_ the end of
|
||||
// the stream, so we need an extra check.
|
||||
if(inp.gcount() == 0) break;
|
||||
|
||||
/*
|
||||
for(int i=0;i<5;i++)
|
||||
cout << (int)buf[i] << " ";
|
||||
cout << endl;
|
||||
*/
|
||||
|
||||
assert(buf[4] == buf[0]);
|
||||
assert(buf[0] == x/2);
|
||||
x++;
|
||||
}
|
||||
cout << " Done\n";
|
||||
}
|
||||
|
||||
struct Dummy2 : Stream
|
||||
{
|
||||
Dummy2()
|
||||
{
|
||||
isWritable = true;
|
||||
isReadable = false;
|
||||
}
|
||||
|
||||
size_t write(const void *ptr, size_t num)
|
||||
{
|
||||
const char *p = (const char*)ptr;
|
||||
cout << " Got: ";
|
||||
for(unsigned i=0;i<num;i++)
|
||||
cout << *(p++) << " ";
|
||||
cout << endl;
|
||||
return num;
|
||||
}
|
||||
};
|
||||
|
||||
void test3()
|
||||
{
|
||||
cout << "\nWriting to dummy stream:\n";
|
||||
|
||||
cout << " Pure dummy test:\n";
|
||||
StreamPtr output(new Dummy2);
|
||||
output->write("testing", 7);
|
||||
|
||||
cout << " Running through MangleOStream:\n";
|
||||
MangleOStream out(output);
|
||||
out << "hello";
|
||||
out << " - are you ok?";
|
||||
cout << " Flushing:\n";
|
||||
out.flush();
|
||||
|
||||
cout << " Writing a hell of a lot of characters:\n";
|
||||
for(int i=0; i<127; i++)
|
||||
out << "xxxxxxxx"; // 127 * 8 = 1016
|
||||
out << "fffffff"; // +7 = 1023
|
||||
cout << " Just one more:\n";
|
||||
out << "y";
|
||||
cout << " And oooone more:\n";
|
||||
out << "z";
|
||||
|
||||
cout << " Flushing again:\n";
|
||||
out.flush();
|
||||
cout << " Writing some more and exiting:\n";
|
||||
out << "blah bleh blob";
|
||||
}
|
||||
|
||||
struct Dummy3 : Stream
|
||||
{
|
||||
int pos;
|
||||
|
||||
Dummy3() : pos(0)
|
||||
{
|
||||
hasPosition = true;
|
||||
isSeekable = true;
|
||||
}
|
||||
|
||||
size_t read(void*, size_t num)
|
||||
{
|
||||
cout << " Reading " << num << " bytes from " << pos << endl;
|
||||
pos += num;
|
||||
return num;
|
||||
}
|
||||
|
||||
void seek(size_t npos) { pos = npos; }
|
||||
size_t tell() const { return pos; }
|
||||
};
|
||||
|
||||
void test4()
|
||||
{
|
||||
cout << "\nTesting seeking;\n";
|
||||
StreamPtr input(new Dummy3);
|
||||
|
||||
cout << " Direct reading:\n";
|
||||
input->read(0,10);
|
||||
input->read(0,5);
|
||||
|
||||
MangleIStream inp(input);
|
||||
|
||||
cout << " Reading from istream:\n";
|
||||
char buf[20];
|
||||
inp.read(buf, 20);
|
||||
inp.read(buf, 20);
|
||||
inp.read(buf, 20);
|
||||
|
||||
cout << " Seeking to 30 and reading again:\n";
|
||||
inp.seekg(30);
|
||||
inp.read(buf, 20);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1();
|
||||
test2();
|
||||
test3();
|
||||
test4();
|
||||
return 0;
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
|
||||
#include "../servers/memory_stream.hpp"
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
int main()
|
||||
{
|
||||
Stream* inp = new MemoryStream("hello world\0", 12);
|
||||
|
||||
cout << "Size: " << inp->size() << endl;
|
||||
cout << "Pos: " << inp->tell() << "\nSeeking...\n";
|
||||
inp->seek(3);
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
char data[12];
|
||||
memset(data, 0, 12);
|
||||
cout << "Reading: " << inp->read(data, 4) << endl;
|
||||
cout << "Four bytes: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << "\nSeeking again...\n";
|
||||
inp->seek(33);
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Eof: " << inp->eof() << "\nSeek to 6\n";
|
||||
inp->seek(6);
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Over-reading: " << inp->read(data, 200) << endl;
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
inp->seek(0);
|
||||
cout << "Finally, reading the entire string: " << inp->read(data,11) << endl;
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
|
||||
cout << "Entire stream from pointer: " << (char*)inp->getPtr() << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
#include "../servers/memory_stream.hpp"
|
||||
#include "../clients/ogre_datastream.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace Ogre;
|
||||
using namespace std;
|
||||
|
||||
int main()
|
||||
{
|
||||
StreamPtr inp(new MemoryStream("hello world", 11));
|
||||
DataStreamPtr p(new Mangle2OgreStream("hello", inp));
|
||||
cout << "Name: " << p->getName() << endl;
|
||||
cout << "As string: " << p->getAsString() << endl;
|
||||
cout << "pos=" << p->tell() << " eof=" << p->eof() << endl;
|
||||
p->seek(0);
|
||||
cout << "pos=" << p->tell() << " eof=" << p->eof() << endl;
|
||||
p->skip(5);
|
||||
p->skip(-2);
|
||||
cout << "pos=" << p->tell() << " eof=" << p->eof() << endl;
|
||||
return 0;
|
||||
}
|
||||
@ -1,9 +0,0 @@
|
||||
pos=0
|
||||
2 bytes: he
|
||||
pos=2
|
||||
pos=4
|
||||
3 bytes: o w
|
||||
pos=6
|
||||
pos=7
|
||||
last 4 bytes: orld
|
||||
entire stream: hello world
|
||||
@ -1,22 +0,0 @@
|
||||
Size: 11
|
||||
Pos: 0
|
||||
Seeking...
|
||||
Pos: 3
|
||||
Reading: 4
|
||||
Four bytes: lo w
|
||||
Eof: 0
|
||||
Pos: 7
|
||||
Seeking again...
|
||||
Pos: 11
|
||||
Eof: 1
|
||||
Seek to 6
|
||||
Eof: 0
|
||||
Pos: 6
|
||||
Over-reading: 5
|
||||
Result: world
|
||||
Eof: 1
|
||||
Pos: 11
|
||||
Finally, reading the entire string: 11
|
||||
Result: hello world
|
||||
Eof: 1
|
||||
Pos: 11
|
||||
@ -1,3 +0,0 @@
|
||||
pos=0 eof=0
|
||||
First 20 bytes: #include "../servers
|
||||
pos=20 eof=0
|
||||
@ -1,12 +0,0 @@
|
||||
|
||||
Creating file
|
||||
size=0 pos=0 eof=0
|
||||
size=5 pos=5 eof=0
|
||||
|
||||
Appending to file
|
||||
size=5 pos=5 eof=0
|
||||
size=12 pos=12 eof=0
|
||||
|
||||
Overwriting file
|
||||
size=0 pos=0 eof=0
|
||||
size=11 pos=11 eof=0
|
||||
@ -1,32 +0,0 @@
|
||||
Testing ASCII reading from memory:
|
||||
Got: hello
|
||||
Got: you
|
||||
Got: world
|
||||
Got: you
|
||||
|
||||
Testing binary reading from non-memory:
|
||||
Done
|
||||
|
||||
Writing to dummy stream:
|
||||
Pure dummy test:
|
||||
Got: t e s t i n g
|
||||
Running through MangleOStream:
|
||||
Flushing:
|
||||
Got: h e l l o - a r e y o u o k ?
|
||||
Writing a hell of a lot of characters:
|
||||
Just one more:
|
||||
And oooone more:
|
||||
Got: x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x f f f f f f f y
|
||||
Flushing again:
|
||||
Got: z
|
||||
Writing some more and exiting:
|
||||
Got: b l a h b l e h b l o b
|
||||
|
||||
Testing seeking;
|
||||
Direct reading:
|
||||
Reading 10 bytes from 0
|
||||
Reading 5 bytes from 10
|
||||
Reading from istream:
|
||||
Reading 1024 bytes from 15
|
||||
Seeking to 30 and reading again:
|
||||
Reading 1024 bytes from 30
|
||||
@ -1,23 +0,0 @@
|
||||
Size: 12
|
||||
Pos: 0
|
||||
Seeking...
|
||||
Pos: 3
|
||||
Reading: 4
|
||||
Four bytes: lo w
|
||||
Eof: 0
|
||||
Pos: 7
|
||||
Seeking again...
|
||||
Pos: 12
|
||||
Eof: 1
|
||||
Seek to 6
|
||||
Eof: 0
|
||||
Pos: 6
|
||||
Over-reading: 6
|
||||
Result: world
|
||||
Eof: 1
|
||||
Pos: 12
|
||||
Finally, reading the entire string: 11
|
||||
Result: hello world
|
||||
Eof: 0
|
||||
Pos: 11
|
||||
Entire stream from pointer: hello world
|
||||
@ -1,5 +0,0 @@
|
||||
Name: hello
|
||||
As string: hello world
|
||||
pos=11 eof=1
|
||||
pos=0 eof=0
|
||||
pos=3 eof=0
|
||||
@ -1,36 +0,0 @@
|
||||
|
||||
Slice 1:
|
||||
--------
|
||||
Size: 6
|
||||
Pos: 0
|
||||
Seeking...
|
||||
Reading 6 bytes
|
||||
Result: hello
|
||||
Pos: 6
|
||||
Eof: 1
|
||||
Seeking:
|
||||
Pos: 2
|
||||
Eof: 0
|
||||
Reading 4 bytes
|
||||
Result: llo
|
||||
Pos: 6
|
||||
Eof: 1
|
||||
Entire stream as pointer: hello
|
||||
|
||||
Slice 2:
|
||||
--------
|
||||
Size: 6
|
||||
Pos: 0
|
||||
Seeking...
|
||||
Reading 6 bytes
|
||||
Result: world
|
||||
Pos: 6
|
||||
Eof: 1
|
||||
Seeking:
|
||||
Pos: 2
|
||||
Eof: 0
|
||||
Reading 4 bytes
|
||||
Result: rld
|
||||
Pos: 6
|
||||
Eof: 1
|
||||
Entire stream as pointer: world
|
||||
@ -1,42 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
|
||||
#include "../filters/slice_stream.hpp"
|
||||
#include "../servers/memory_stream.hpp"
|
||||
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
void test(StreamPtr inp)
|
||||
{
|
||||
cout << "Size: " << inp->size() << endl;
|
||||
cout << "Pos: " << inp->tell() << "\nSeeking...\n";
|
||||
char data[6];
|
||||
memset(data, 0, 6);
|
||||
cout << "Reading " << inp->read(data, 6) << " bytes\n";
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
inp->seek(2);
|
||||
cout << "Seeking:\nPos: " << inp->tell() << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Reading " << inp->read(data, 6) << " bytes\n";
|
||||
cout << "Result: " << data << endl;
|
||||
cout << "Pos: " << inp->tell() << endl;
|
||||
cout << "Eof: " << inp->eof() << endl;
|
||||
cout << "Entire stream as pointer: " << (char*)inp->getPtr() << endl;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
StreamPtr orig (new MemoryStream("hello\0world\0", 12));
|
||||
StreamPtr slice1 (new SliceStream(orig,0,6));
|
||||
StreamPtr slice2 (new SliceStream(orig,6,6));
|
||||
|
||||
cout << "\nSlice 1:\n--------\n";
|
||||
test(slice1);
|
||||
cout << "\nSlice 2:\n--------\n";
|
||||
test(slice2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
make || exit
|
||||
|
||||
mkdir -p output
|
||||
|
||||
PROGS=*_test
|
||||
|
||||
for a in $PROGS; do
|
||||
if [ -f "output/$a.out" ]; then
|
||||
echo "Running $a:"
|
||||
./$a | diff output/$a.out -
|
||||
else
|
||||
echo "Creating $a.out"
|
||||
./$a > "output/$a.out"
|
||||
git add "output/$a.out"
|
||||
fi
|
||||
done
|
||||
@ -1,85 +0,0 @@
|
||||
#include "ogre_archive.hpp"
|
||||
|
||||
#include "../../stream/clients/ogre_datastream.hpp"
|
||||
|
||||
using namespace Mangle::VFS;
|
||||
using namespace Mangle::Stream;
|
||||
|
||||
Ogre::DataStreamPtr MangleArchive::open(const Ogre::String& filename) const
|
||||
{
|
||||
return Ogre::DataStreamPtr(new Mangle2OgreStream
|
||||
(filename, vfs->open(filename)));
|
||||
}
|
||||
|
||||
static void fill(Ogre::FileInfoList &out, FileInfoList &in)
|
||||
{
|
||||
int size = in.size();
|
||||
out.resize(size);
|
||||
|
||||
for(int i=0; i<size; i++)
|
||||
{
|
||||
out[i].filename = in[i].name;
|
||||
out[i].basename = in[i].basename;
|
||||
out[i].path = ""; // FIXME
|
||||
out[i].uncompressedSize = in[i].size;
|
||||
out[i].compressedSize = in[i].size;
|
||||
}
|
||||
}
|
||||
|
||||
static void fill(Ogre::StringVector &out, FileInfoList &in)
|
||||
{
|
||||
int size = in.size();
|
||||
out.resize(size);
|
||||
|
||||
for(int i=0; i<size; i++)
|
||||
out[i] = in[i].name;
|
||||
}
|
||||
|
||||
Ogre::StringVectorPtr MangleArchive::list(bool recursive, bool dirs)
|
||||
{
|
||||
assert(vfs->hasList);
|
||||
FileInfoListPtr lst = vfs->list("", recursive, dirs);
|
||||
Ogre::StringVector *res = new Ogre::StringVector;
|
||||
|
||||
fill(*res, *lst);
|
||||
|
||||
return Ogre::StringVectorPtr(res);
|
||||
}
|
||||
|
||||
Ogre::FileInfoListPtr MangleArchive::listFileInfo(bool recursive, bool dirs)
|
||||
{
|
||||
assert(vfs->hasList);
|
||||
FileInfoListPtr lst = vfs->list("", recursive, dirs);
|
||||
Ogre::FileInfoList *res = new Ogre::FileInfoList;
|
||||
|
||||
fill(*res, *lst);
|
||||
|
||||
return Ogre::FileInfoListPtr(res);
|
||||
}
|
||||
|
||||
// Find functions will only work if vfs->hasFind is set.
|
||||
Ogre::StringVectorPtr MangleArchive::find(const Ogre::String& pattern,
|
||||
bool recursive,
|
||||
bool dirs)
|
||||
{
|
||||
assert(vfs->hasFind);
|
||||
FileInfoListPtr lst = vfs->find(pattern, recursive, dirs);
|
||||
Ogre::StringVector *res = new Ogre::StringVector;
|
||||
|
||||
fill(*res, *lst);
|
||||
|
||||
return Ogre::StringVectorPtr(res);
|
||||
}
|
||||
|
||||
Ogre::FileInfoListPtr MangleArchive::findFileInfo(const Ogre::String& pattern,
|
||||
bool recursive,
|
||||
bool dirs)
|
||||
{
|
||||
assert(vfs->hasFind);
|
||||
FileInfoListPtr lst = vfs->find(pattern, recursive, dirs);
|
||||
Ogre::FileInfoList *res = new Ogre::FileInfoList;
|
||||
|
||||
fill(*res, *lst);
|
||||
|
||||
return Ogre::FileInfoListPtr(res);
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
#ifndef MANGLE_VFS_OGRECLIENT_H
|
||||
#define MANGLE_VFS_OGRECLIENT_H
|
||||
|
||||
#include <OgreArchive.h>
|
||||
#include <assert.h>
|
||||
#include "../vfs.hpp"
|
||||
|
||||
namespace Mangle {
|
||||
namespace VFS {
|
||||
|
||||
/** An OGRE Archive implementation that wraps a Mangle::VFS
|
||||
filesystem.
|
||||
|
||||
This has been built and tested against OGRE 1.6.2, and has been
|
||||
extended for OGRE 1.7. You might have to make your own
|
||||
modifications if you're working with newer (or older) versions.
|
||||
*/
|
||||
class MangleArchive : public Ogre::Archive
|
||||
{
|
||||
VFSPtr vfs;
|
||||
|
||||
public:
|
||||
MangleArchive(VFSPtr _vfs, const std::string &name,
|
||||
const std::string &archType = "Mangle")
|
||||
: Ogre::Archive(name, archType)
|
||||
, vfs(_vfs)
|
||||
{}
|
||||
|
||||
bool isCaseSensitive() const { return vfs->isCaseSensitive; }
|
||||
|
||||
// These do nothing. You have to load / unload the archive in the
|
||||
// constructor/destructor.
|
||||
void load() {}
|
||||
void unload() {}
|
||||
|
||||
bool exists(const Ogre::String& filename)
|
||||
{ return vfs->isFile(filename); }
|
||||
|
||||
time_t getModifiedTime(const Ogre::String& filename)
|
||||
{ return vfs->stat(filename)->time; }
|
||||
|
||||
// With both these we support both OGRE 1.6 and 1.7
|
||||
Ogre::DataStreamPtr open(const Ogre::String& filename) const;
|
||||
Ogre::DataStreamPtr open(const Ogre::String& filename, bool readOnly) const
|
||||
{ return open(filename); }
|
||||
|
||||
Ogre::StringVectorPtr list(bool recursive = true, bool dirs = false);
|
||||
Ogre::FileInfoListPtr listFileInfo(bool recursive = true, bool dirs = false);
|
||||
|
||||
// Find functions will only work if vfs->hasFind is set.
|
||||
Ogre::StringVectorPtr find(const Ogre::String& pattern, bool recursive = true,
|
||||
bool dirs = false);
|
||||
Ogre::FileInfoListPtr findFileInfo(const Ogre::String& pattern,
|
||||
bool recursive = true,
|
||||
bool dirs = false);
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,61 +0,0 @@
|
||||
#include "ogre_vfs.hpp"
|
||||
#include "../../stream/servers/ogre_datastream.hpp"
|
||||
|
||||
using namespace Mangle::VFS;
|
||||
using namespace Mangle::Stream;
|
||||
|
||||
OgreVFS::OgreVFS(const std::string &_group)
|
||||
: group(_group)
|
||||
{
|
||||
hasList = true;
|
||||
hasFind = true;
|
||||
isCaseSensitive = true;
|
||||
|
||||
// Get the group manager once
|
||||
gm = Ogre::ResourceGroupManager::getSingletonPtr();
|
||||
|
||||
// Use the default group if none was specified
|
||||
if(group.empty())
|
||||
group = gm->getWorldResourceGroupName();
|
||||
}
|
||||
|
||||
StreamPtr OgreVFS::open(const std::string &name)
|
||||
{
|
||||
Ogre::DataStreamPtr data = gm->openResource(name, group);
|
||||
return StreamPtr(new OgreStream(data));
|
||||
}
|
||||
|
||||
static void fill(FileInfoList &out, Ogre::FileInfoList &in, bool dirs)
|
||||
{
|
||||
int size = in.size();
|
||||
out.resize(size);
|
||||
|
||||
for(int i=0; i<size; i++)
|
||||
{
|
||||
out[i].name = in[i].filename;
|
||||
out[i].basename = in[i].basename;
|
||||
out[i].size = in[i].uncompressedSize;
|
||||
out[i].isDir = dirs;
|
||||
out[i].time = 0;
|
||||
}
|
||||
}
|
||||
|
||||
FileInfoListPtr OgreVFS::list(const std::string& dir,
|
||||
bool recurse,
|
||||
bool dirs) const
|
||||
{
|
||||
Ogre::FileInfoListPtr olist = gm->listResourceFileInfo(group, dirs);
|
||||
FileInfoListPtr res(new FileInfoList);
|
||||
fill(*res, *olist, dirs);
|
||||
return res;
|
||||
}
|
||||
|
||||
FileInfoListPtr OgreVFS::find(const std::string& pattern,
|
||||
bool recursive,
|
||||
bool dirs) const
|
||||
{
|
||||
Ogre::FileInfoListPtr olist = gm->findResourceFileInfo(group, pattern, dirs);
|
||||
FileInfoListPtr res(new FileInfoList);
|
||||
fill(*res, *olist, dirs);
|
||||
return res;
|
||||
}
|
||||
@ -1,70 +0,0 @@
|
||||
#ifndef MANGLE_VFS_OGRESERVER_H
|
||||
#define MANGLE_VFS_OGRESERVER_H
|
||||
|
||||
#include "../vfs.hpp"
|
||||
#include <OgreResourceGroupManager.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace VFS {
|
||||
|
||||
/** @brief An interface into the OGRE VFS system.
|
||||
|
||||
This class does NOT wrap a single Ogre::Archive, but rather an
|
||||
entire resource group in Ogre. You can use this class to tap into
|
||||
all paths, Zip files, custom archives on so on that have been
|
||||
inserted into Ogre as resource locations.
|
||||
|
||||
This has been built and tested against OGRE 1.6.2. You might have
|
||||
to make your own modifications if you're working with newer (or
|
||||
older) versions.
|
||||
*/
|
||||
class OgreVFS : public VFS
|
||||
{
|
||||
std::string group;
|
||||
Ogre::ResourceGroupManager *gm;
|
||||
|
||||
public:
|
||||
/** @brief Constructor
|
||||
|
||||
OGRE must be initialized (ie. you must have created an
|
||||
Ogre::Root object somewhere) before calling this.
|
||||
|
||||
@param group Optional resource group name. If none is given,
|
||||
OGRE's default (or 'World') resource group is used.
|
||||
*/
|
||||
OgreVFS(const std::string &_group = "");
|
||||
|
||||
/// Open a new data stream. Deleting the object should be enough to
|
||||
/// close it.
|
||||
virtual Stream::StreamPtr open(const std::string &name);
|
||||
|
||||
/// Check for the existence of a file
|
||||
virtual bool isFile(const std::string &name) const
|
||||
{ return gm->resourceExists(group, name); }
|
||||
|
||||
/// This doesn't work, always returns false.
|
||||
virtual bool isDir(const std::string &name) const
|
||||
{ return false; }
|
||||
|
||||
/// This doesn't work.
|
||||
virtual FileInfoPtr stat(const std::string &name) const
|
||||
{ return FileInfoPtr(); }
|
||||
|
||||
/// List all entries in a given directory. A blank dir should be
|
||||
/// interpreted as a the root/current directory of the archive. If
|
||||
/// dirs is true, list directories instead of files. OGRE note: The
|
||||
/// ogre resource systemd does not support recursive listing of
|
||||
/// files. We might make a separate filter for this later.
|
||||
virtual FileInfoListPtr list(const std::string& dir = "",
|
||||
bool recurse=true,
|
||||
bool dirs=false) const;
|
||||
|
||||
/// Find files after a given pattern. Wildcards (*) are
|
||||
/// supported.
|
||||
virtual FileInfoListPtr find(const std::string& pattern,
|
||||
bool recursive=true,
|
||||
bool dirs=false) const;
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1,71 +0,0 @@
|
||||
#ifndef MANGLE_VFS_PHYSFS_SERVER_H
|
||||
#define MANGLE_VFS_PHYSFS_SERVER_H
|
||||
|
||||
#include "../vfs.hpp"
|
||||
#include "../../stream/servers/phys_stream.hpp"
|
||||
|
||||
#include <physfs.h>
|
||||
#include <assert.h>
|
||||
|
||||
namespace Mangle {
|
||||
namespace VFS {
|
||||
|
||||
/** @brief An interface into the PhysFS virtual file system library
|
||||
|
||||
You have to set up PhysFS on your own before using this class.
|
||||
*/
|
||||
class PhysVFS : public VFS
|
||||
{
|
||||
public:
|
||||
PhysVFS()
|
||||
{
|
||||
hasList = true;
|
||||
hasFind = false;
|
||||
isCaseSensitive = true;
|
||||
}
|
||||
|
||||
/// Open a new data stream. Deleting the object should be enough to
|
||||
/// close it.
|
||||
virtual Stream::StreamPtr open(const std::string &name)
|
||||
{ return Stream::StreamPtr(new Stream::PhysFile(PHYSFS_openRead(name.c_str()))); }
|
||||
|
||||
/// Check for the existence of a file
|
||||
virtual bool isFile(const std::string &name) const
|
||||
{ return PHYSFS_exists(name.c_str()); }
|
||||
|
||||
/// Checks for a directory
|
||||
virtual bool isDir(const std::string &name) const
|
||||
{ return PHYSFS_isDirectory(name.c_str()); }
|
||||
|
||||
/// This doesn't work
|
||||
virtual FileInfoPtr stat(const std::string &name) const
|
||||
{ assert(0); return FileInfoPtr(); }
|
||||
|
||||
virtual FileInfoListPtr list(const std::string& dir = "",
|
||||
bool recurse=true,
|
||||
bool dirs=false) const
|
||||
{
|
||||
char **files = PHYSFS_enumerateFiles(dir.c_str());
|
||||
FileInfoListPtr lst(new FileInfoList);
|
||||
|
||||
// Add all teh files
|
||||
int i = 0;
|
||||
while(files[i] != NULL)
|
||||
{
|
||||
FileInfo fi;
|
||||
fi.name = files[i];
|
||||
fi.isDir = false;
|
||||
|
||||
lst->push_back(fi);
|
||||
}
|
||||
return lst;
|
||||
}
|
||||
|
||||
virtual FileInfoListPtr find(const std::string& pattern,
|
||||
bool recursive=true,
|
||||
bool dirs=false) const
|
||||
{ assert(0); }
|
||||
};
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
@ -1 +0,0 @@
|
||||
*_test
|
||||
@ -1,25 +0,0 @@
|
||||
GCC=g++ -I../ -Wall
|
||||
|
||||
all: dummy_test ogre_client_test ogre_resource_test ogre_server_test physfs_server_test
|
||||
|
||||
I_OGRE=$(shell pkg-config --cflags OGRE)
|
||||
L_OGRE=$(shell pkg-config --libs OGRE)
|
||||
L_PHYSFS=-lphysfs
|
||||
|
||||
ogre_client_test: ogre_client_test.cpp dummy_vfs.cpp ../vfs.hpp ../clients/ogre_archive.hpp ../clients/ogre_archive.cpp
|
||||
$(GCC) $< ../clients/ogre_archive.cpp -o $@ $(I_OGRE) $(L_OGRE)
|
||||
|
||||
ogre_resource_test: ogre_resource_test.cpp
|
||||
$(GCC) $< -o $@ $(I_OGRE) $(L_OGRE)
|
||||
|
||||
ogre_server_test: ogre_server_test.cpp ../vfs.hpp ../servers/ogre_vfs.hpp ../servers/ogre_vfs.cpp
|
||||
$(GCC) $< -o $@ $(I_OGRE) $(L_OGRE) ../servers/ogre_vfs.cpp
|
||||
|
||||
physfs_server_test: physfs_server_test.cpp ../vfs.hpp ../servers/physfs_vfs.hpp
|
||||
$(GCC) $< -o $@ $(L_PHYSFS)
|
||||
|
||||
dummy_test: dummy_test.cpp dummy_vfs.cpp ../vfs.hpp
|
||||
$(GCC) $< -o $@
|
||||
|
||||
clean:
|
||||
rm *_test
|
||||
@ -1,42 +0,0 @@
|
||||
#include "dummy_vfs.cpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void print(FileInfo &inf)
|
||||
{
|
||||
cout << "name: " << inf.name << endl;
|
||||
cout << "basename: " << inf.basename << endl;
|
||||
cout << "isDir: " << inf.isDir << endl;
|
||||
cout << "size: " << inf.size << endl;
|
||||
cout << "time: " << inf.time << endl;
|
||||
}
|
||||
void print(FileInfoPtr inf) { print(*inf); }
|
||||
|
||||
void print(FileInfoList &lst)
|
||||
{
|
||||
for(unsigned i=0; i<lst.size(); i++)
|
||||
print(lst[i]);
|
||||
}
|
||||
void print(FileInfoListPtr lst) { print(*lst); }
|
||||
|
||||
int main()
|
||||
{
|
||||
DummyVFS vfs;
|
||||
|
||||
cout << "Listing all files:\n";
|
||||
print(vfs.list());
|
||||
cout << "\nStat for single files:\n";
|
||||
print(vfs.stat("file1"));
|
||||
cout << endl;
|
||||
print(vfs.stat("dir/file2"));
|
||||
cout << endl;
|
||||
print(vfs.stat("dir"));
|
||||
|
||||
StreamPtr inp = vfs.open("file1");
|
||||
cout << "filesize: " << inp->size() << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,117 +0,0 @@
|
||||
// This file is shared between several test programs
|
||||
#include "vfs.hpp"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../../stream/servers/memory_stream.hpp"
|
||||
|
||||
using namespace Mangle::VFS;
|
||||
using namespace Mangle::Stream;
|
||||
|
||||
class DummyVFS : public VFS
|
||||
{
|
||||
public:
|
||||
DummyVFS()
|
||||
{
|
||||
hasFind = false;
|
||||
hasList = true;
|
||||
isCaseSensitive = true;
|
||||
}
|
||||
|
||||
// We only support opening 'file1' at the moment.
|
||||
StreamPtr open(const std::string &name)
|
||||
{
|
||||
assert(name == "file1");
|
||||
return StreamPtr(new MemoryStream("hello world", 11));
|
||||
}
|
||||
|
||||
bool isFile(const std::string &name) const
|
||||
{
|
||||
return (name == "file1" ||
|
||||
name == "dir/file2");
|
||||
}
|
||||
|
||||
bool isDir(const std::string &name) const
|
||||
{
|
||||
return name == "dir";
|
||||
}
|
||||
|
||||
/// Get info about a single file
|
||||
FileInfoPtr stat(const std::string &name) const
|
||||
{
|
||||
FileInfoPtr fi(new FileInfo);
|
||||
fi->name = name;
|
||||
fi->time = 0;
|
||||
|
||||
if(isFile(name))
|
||||
{
|
||||
if(name == "dir/file2")
|
||||
{
|
||||
fi->basename = "file2";
|
||||
fi->size = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
fi->basename = "file1";
|
||||
fi->size = 1;
|
||||
}
|
||||
fi->isDir = false;
|
||||
}
|
||||
else if(isDir(name))
|
||||
{
|
||||
fi->basename = "dir";
|
||||
fi->isDir = true;
|
||||
fi->size = 0;
|
||||
}
|
||||
else assert(0);
|
||||
|
||||
return fi;
|
||||
}
|
||||
|
||||
/// List all entries in a given directory. A blank dir should be
|
||||
/// interpreted as a the root/current directory of the archive. If
|
||||
/// dirs is true, list directories instead of files.
|
||||
virtual FileInfoListPtr list(const std::string& dir = "",
|
||||
bool recurse=true,
|
||||
bool dirs=false) const
|
||||
{
|
||||
assert(dir == "");
|
||||
|
||||
FileInfoListPtr fl(new FileInfoList);
|
||||
|
||||
FileInfo fi;
|
||||
|
||||
if(!dirs)
|
||||
{
|
||||
fi.name = "file1";
|
||||
fi.basename = "file1";
|
||||
fi.isDir = false;
|
||||
fi.size = 1;
|
||||
fi.time = 0;
|
||||
fl->push_back(fi);
|
||||
|
||||
if(recurse)
|
||||
{
|
||||
fi.name = "dir/file2";
|
||||
fi.basename = "file2";
|
||||
fi.size = 2;
|
||||
fl->push_back(fi);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fi.name = "dir";
|
||||
fi.basename = "dir";
|
||||
fi.isDir = true;
|
||||
fi.size = 0;
|
||||
fi.time = 0;
|
||||
fl->push_back(fi);
|
||||
}
|
||||
return fl;
|
||||
}
|
||||
|
||||
FileInfoListPtr find(const std::string& pattern,
|
||||
bool recursive=true,
|
||||
bool dirs=false) const
|
||||
{ assert(0); }
|
||||
};
|
||||
@ -1,39 +0,0 @@
|
||||
#include "dummy_vfs.cpp"
|
||||
#include "../clients/ogre_archive.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace Ogre;
|
||||
using namespace std;
|
||||
|
||||
void print(StringVectorPtr lst)
|
||||
{
|
||||
int s = lst->size();
|
||||
|
||||
for(int i=0; i<s; i++)
|
||||
{
|
||||
cout << " " << (*lst)[i] << endl;
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
VFSPtr vfs(new DummyVFS());
|
||||
MangleArchive arc(vfs, "dummy");
|
||||
|
||||
cout << "Case: " << arc.isCaseSensitive() << endl;
|
||||
cout << "Name: " << arc.getName() << endl;
|
||||
cout << "Type: " << arc.getType() << endl;
|
||||
cout << "All files:\n";
|
||||
print(arc.list());
|
||||
cout << "Non-recursive:\n";
|
||||
print(arc.list(false, false));
|
||||
cout << "Dirs:\n";
|
||||
print(arc.list(false, true));
|
||||
|
||||
DataStreamPtr file = arc.open("file1");
|
||||
|
||||
cout << "filesize: " << file->size() << endl;
|
||||
cout << "contents: " << file->getAsString() << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <OgreRoot.h>
|
||||
#include <OgreResourceGroupManager.h>
|
||||
|
||||
/*
|
||||
This isn't really a test of our implementation, but a test of using
|
||||
the Ogre resource system to find files. If the Ogre interface
|
||||
changes and you have to change this test, you will have to change
|
||||
the servers/ogre_vfs.cpp implementation equivalently.
|
||||
|
||||
*/
|
||||
|
||||
using namespace std;
|
||||
using namespace Ogre;
|
||||
|
||||
ResourceGroupManager *gm;
|
||||
String group;
|
||||
|
||||
void find(const std::string &fileName)
|
||||
{
|
||||
cout << "\nFile: " << fileName << endl;
|
||||
|
||||
if(!gm->resourceExists(group, fileName))
|
||||
{
|
||||
cout << "Does not exist\n";
|
||||
return;
|
||||
}
|
||||
|
||||
DataStreamPtr data = gm->openResource(fileName, group);
|
||||
|
||||
cout << "Size: " << data->size() << endl;
|
||||
cout << "First line: " << data->getLine() << "\n";
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// Disable logging
|
||||
new LogManager;
|
||||
Log *log = LogManager::getSingleton().createLog("");
|
||||
log->setDebugOutputEnabled(false);
|
||||
|
||||
// Set up Ogre
|
||||
Root root("","","");
|
||||
|
||||
root.addResourceLocation("./", "FileSystem", "General");
|
||||
|
||||
gm = ResourceGroupManager::getSingletonPtr();
|
||||
group = gm->getWorldResourceGroupName();
|
||||
|
||||
find("Makefile");
|
||||
find("ogre_resource_test.cpp");
|
||||
find("bleh");
|
||||
|
||||
cout << "\nAll source files:\n";
|
||||
FileInfoListPtr list = gm->findResourceFileInfo(group, "*.cpp");
|
||||
FileInfoList::iterator it, end;
|
||||
it = list->begin();
|
||||
end = list->end();
|
||||
for(; it != end; it++)
|
||||
cout << " " << it->filename << endl;
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
#include "../servers/ogre_vfs.hpp"
|
||||
|
||||
#include <Ogre.h>
|
||||
|
||||
#include "server_common.cpp"
|
||||
|
||||
Ogre::Root *root;
|
||||
|
||||
void setupOgre()
|
||||
{
|
||||
using namespace Ogre;
|
||||
|
||||
// Disable logging
|
||||
new LogManager;
|
||||
Log *log = LogManager::getSingleton().createLog("");
|
||||
log->setDebugOutputEnabled(false);
|
||||
|
||||
// Set up Root
|
||||
root = new Root("","","");
|
||||
|
||||
// Add a zip file and the current directory
|
||||
root->addResourceLocation("test.zip", "Zip", "General");
|
||||
root->addResourceLocation("./", "FileSystem", "General");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// Set up the engine
|
||||
setupOgre();
|
||||
|
||||
// This is our entry point into the resource file system
|
||||
OgreVFS vfs("General");
|
||||
|
||||
// Run the test
|
||||
testAll(vfs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
Listing all files:
|
||||
name: file1
|
||||
basename: file1
|
||||
isDir: 0
|
||||
size: 1
|
||||
time: 0
|
||||
name: dir/file2
|
||||
basename: file2
|
||||
isDir: 0
|
||||
size: 2
|
||||
time: 0
|
||||
|
||||
Stat for single files:
|
||||
name: file1
|
||||
basename: file1
|
||||
isDir: 0
|
||||
size: 1
|
||||
time: 0
|
||||
|
||||
name: dir/file2
|
||||
basename: file2
|
||||
isDir: 0
|
||||
size: 2
|
||||
time: 0
|
||||
|
||||
name: dir
|
||||
basename: dir
|
||||
isDir: 1
|
||||
size: 0
|
||||
time: 0
|
||||
filesize: 11
|
||||
@ -1,12 +0,0 @@
|
||||
Case: 1
|
||||
Name: dummy
|
||||
Type: Mangle
|
||||
All files:
|
||||
file1
|
||||
dir/file2
|
||||
Non-recursive:
|
||||
file1
|
||||
Dirs:
|
||||
dir
|
||||
filesize: 11
|
||||
contents: hello world
|
||||
@ -1,20 +0,0 @@
|
||||
|
||||
File: Makefile
|
||||
Size: 828
|
||||
First line: GCC=g++ -I../
|
||||
|
||||
File: ogre_resource_test.cpp
|
||||
Size: 1437
|
||||
First line: #include <iostream>
|
||||
|
||||
File: bleh
|
||||
Does not exist
|
||||
|
||||
All source files:
|
||||
physfs_server_test.cpp
|
||||
dummy_test.cpp
|
||||
ogre_resource_test.cpp
|
||||
server_common.cpp
|
||||
dummy_vfs.cpp
|
||||
ogre_client_test.cpp
|
||||
ogre_server_test.cpp
|
||||
@ -1,11 +0,0 @@
|
||||
|
||||
File: Makefile
|
||||
Size: 828
|
||||
First 12 bytes: GCC=g++ -I..
|
||||
|
||||
File: testfile.txt
|
||||
Size: 13
|
||||
First 12 bytes: hello world!
|
||||
|
||||
File: blah_bleh
|
||||
File doesn't exist
|
||||
@ -1,11 +0,0 @@
|
||||
|
||||
File: Makefile
|
||||
Size: 828
|
||||
First 12 bytes: GCC=g++ -I..
|
||||
|
||||
File: testfile.txt
|
||||
Size: 13
|
||||
First 12 bytes: hello world!
|
||||
|
||||
File: blah_bleh
|
||||
File doesn't exist
|
||||
@ -1,21 +0,0 @@
|
||||
#include "../servers/physfs_vfs.hpp"
|
||||
|
||||
#include "server_common.cpp"
|
||||
|
||||
#include <physfs.h>
|
||||
|
||||
int main()
|
||||
{
|
||||
// Set up the library and paths
|
||||
PHYSFS_init("blah");
|
||||
PHYSFS_addToSearchPath("test.zip", 1);
|
||||
PHYSFS_addToSearchPath("./", 1);
|
||||
|
||||
// Create our interface
|
||||
PhysVFS vfs;
|
||||
|
||||
// Run the test
|
||||
testAll(vfs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,33 +0,0 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace Mangle::VFS;
|
||||
using namespace Mangle::Stream;
|
||||
using namespace std;
|
||||
|
||||
void find(VFS &vfs, const std::string &file)
|
||||
{
|
||||
cout << "\nFile: " << file << endl;
|
||||
|
||||
if(!vfs.isFile(file))
|
||||
{
|
||||
cout << "File doesn't exist\n";
|
||||
return;
|
||||
}
|
||||
|
||||
StreamPtr data = vfs.open(file);
|
||||
|
||||
cout << "Size: " << data->size() << endl;
|
||||
|
||||
char buf[13];
|
||||
buf[12] = 0;
|
||||
data->read(buf, 12);
|
||||
|
||||
cout << "First 12 bytes: " << buf << "\n";
|
||||
}
|
||||
|
||||
void testAll(VFS &vfs)
|
||||
{
|
||||
find(vfs, "Makefile"); // From the file system
|
||||
find(vfs, "testfile.txt"); // From the zip
|
||||
find(vfs, "blah_bleh"); // Doesn't exist
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
make || exit
|
||||
|
||||
mkdir -p output
|
||||
|
||||
PROGS=*_test
|
||||
|
||||
for a in $PROGS; do
|
||||
if [ -f "output/$a.out" ]; then
|
||||
echo "Running $a:"
|
||||
./$a | diff output/$a.out -
|
||||
else
|
||||
echo "Creating $a.out"
|
||||
./$a > "output/$a.out"
|
||||
git add "output/$a.out"
|
||||
fi
|
||||
done
|
||||
Binary file not shown.
@ -1,87 +0,0 @@
|
||||
#ifndef MANGLE_VFS_H
|
||||
#define MANGLE_VFS_H
|
||||
|
||||
#include "../stream/stream.hpp"
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace Mangle {
|
||||
namespace VFS {
|
||||
|
||||
/// Generic file info structure
|
||||
struct FileInfo
|
||||
{
|
||||
/// Full name, including path
|
||||
std::string name;
|
||||
|
||||
/// Base name, not including path
|
||||
std::string basename;
|
||||
|
||||
/// Is this a directory?
|
||||
bool isDir;
|
||||
|
||||
/// File size
|
||||
size_t size;
|
||||
|
||||
/// Last modification date
|
||||
time_t time;
|
||||
};
|
||||
|
||||
typedef std::vector<FileInfo> FileInfoList;
|
||||
|
||||
typedef boost::shared_ptr<FileInfo> FileInfoPtr;
|
||||
typedef boost::shared_ptr<FileInfoList> FileInfoListPtr;
|
||||
|
||||
/** An interface to any file system or other provider of named data
|
||||
streams
|
||||
*/
|
||||
class VFS
|
||||
{
|
||||
public:
|
||||
// Feature options. These should be set in the constructor.
|
||||
|
||||
/// If true, the list() function work
|
||||
bool hasList;
|
||||
|
||||
/// If true, the find() function work
|
||||
bool hasFind;
|
||||
|
||||
/// If true, the file system is case sensitive
|
||||
bool isCaseSensitive;
|
||||
|
||||
/// Virtual destructor
|
||||
virtual ~VFS() {}
|
||||
|
||||
/// Open a new data stream. Deleting the object (letting all the
|
||||
/// pointers to it go out of scope) should be enough to close it.
|
||||
virtual Stream::StreamPtr open(const std::string &name) = 0;
|
||||
|
||||
/// Check for the existence of a file
|
||||
virtual bool isFile(const std::string &name) const = 0;
|
||||
|
||||
/// Check for the existence of a directory
|
||||
virtual bool isDir(const std::string &name) const = 0;
|
||||
|
||||
/// Get info about a single file
|
||||
virtual FileInfoPtr stat(const std::string &name) const = 0;
|
||||
|
||||
/// List all entries in a given directory. A blank dir should be
|
||||
/// interpreted as a the root/current directory of the archive. If
|
||||
/// dirs is true, list directories instead of files.
|
||||
virtual FileInfoListPtr list(const std::string& dir = "",
|
||||
bool recurse=true,
|
||||
bool dirs=false) const = 0;
|
||||
|
||||
/// Find files after a given pattern. Wildcards (*) are
|
||||
/// supported. Only valid if 'hasFind' is true. Don't implement your
|
||||
/// own pattern matching here if the backend doesn't support it
|
||||
/// natively; use a filter instead.
|
||||
virtual FileInfoListPtr find(const std::string& pattern,
|
||||
bool recursive=true,
|
||||
bool dirs=false) const = 0;
|
||||
};
|
||||
|
||||
typedef boost::shared_ptr<VFS> VFSPtr;
|
||||
|
||||
}} // namespaces
|
||||
#endif
|
||||
Loading…
Reference in New Issue