summaryrefslogtreecommitdiffstats
path: root/kviewshell/plugins/djvu/libdjvu/DataPool.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kviewshell/plugins/djvu/libdjvu/DataPool.h
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kviewshell/plugins/djvu/libdjvu/DataPool.h')
-rw-r--r--kviewshell/plugins/djvu/libdjvu/DataPool.h627
1 files changed, 627 insertions, 0 deletions
diff --git a/kviewshell/plugins/djvu/libdjvu/DataPool.h b/kviewshell/plugins/djvu/libdjvu/DataPool.h
new file mode 100644
index 00000000..fb4bea4e
--- /dev/null
+++ b/kviewshell/plugins/djvu/libdjvu/DataPool.h
@@ -0,0 +1,627 @@
+//C- -*- C++ -*-
+//C- -------------------------------------------------------------------
+//C- DjVuLibre-3.5
+//C- Copyright (c) 2002 Leon Bottou and Yann Le Cun.
+//C- Copyright (c) 2001 AT&T
+//C-
+//C- This software is subject to, and may be distributed under, the
+//C- GNU General Public License, Version 2. The license should have
+//C- accompanied the software or you may obtain a copy of the license
+//C- from the Free Software Foundation at http://www.fsf.org .
+//C-
+//C- This program is distributed in the hope that it will be useful,
+//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
+//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//C- GNU General Public License for more details.
+//C-
+//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library
+//C- distributed by Lizardtech Software. On July 19th 2002, Lizardtech
+//C- Software authorized us to replace the original DjVu(r) Reference
+//C- Library notice by the following text (see doc/lizard2002.djvu):
+//C-
+//C- ------------------------------------------------------------------
+//C- | DjVu (r) Reference Library (v. 3.5)
+//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
+//C- | The DjVu Reference Library is protected by U.S. Pat. No.
+//C- | 6,058,214 and patents pending.
+//C- |
+//C- | This software is subject to, and may be distributed under, the
+//C- | GNU General Public License, Version 2. The license should have
+//C- | accompanied the software or you may obtain a copy of the license
+//C- | from the Free Software Foundation at http://www.fsf.org .
+//C- |
+//C- | The computer code originally released by LizardTech under this
+//C- | license and unmodified by other parties is deemed "the LIZARDTECH
+//C- | ORIGINAL CODE." Subject to any third party intellectual property
+//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
+//C- | non-exclusive license to make, use, sell, or otherwise dispose of
+//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
+//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
+//C- | General Public License. This grant only confers the right to
+//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
+//C- | the extent such infringement is reasonably necessary to enable
+//C- | recipient to make, have made, practice, sell, or otherwise dispose
+//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
+//C- | any greater extent that may be necessary to utilize further
+//C- | modifications or combinations.
+//C- |
+//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
+//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
+//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+//C- +------------------------------------------------------------------
+//
+// $Id: DataPool.h,v 1.10 2003/11/07 22:08:20 leonb Exp $
+// $Name: release_3_5_15 $
+
+#ifndef _DATAPOOL_H
+#define _DATAPOOL_H
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#if NEED_GNUG_PRAGMAS
+# pragma interface
+#endif
+
+
+#include "GThreads.h"
+#include "GString.h"
+#include "GURL.h"
+
+#ifdef HAVE_NAMESPACES
+namespace DJVU {
+# ifdef NOT_DEFINED // Just to fool emacs c++ mode
+}
+#endif
+#endif
+
+class ByteStream;
+
+/** @name DataPool.h
+ Files #"DataPool.h"# and #"DataPool.cpp"# implement classes \Ref{DataPool}
+ and \Ref{DataRange} used by DjVu decoder to access data.
+
+ The main goal of class \Ref{DataPool} is to provide concurrent access
+ to the same data from many threads with a possibility to add data
+ from yet another thread. It is especially important in the case of the
+ Netscape plugin when data is not immediately available, but decoding
+ should be started as soon as possible. In this situation it is vital
+ to provide transparent access to the data from many threads possibly
+ blocking readers that try to access information that has not been
+ received yet.
+
+ When the data is local though, it can be accessed directly using
+ standard IO mechanism. To provide a uniform interface for decoding
+ routines, \Ref{DataPool} supports file mode as well.
+
+ @memo Thread safe data storage
+ @author Andrei Erofeev <eaf@geocities.com>
+ @version #$Id: DataPool.h,v 1.10 2003/11/07 22:08:20 leonb Exp $#
+*/
+
+//@{
+
+/** Thread safe data storage.
+ The purpose of #DataPool# is to provide a uniform interface for
+ accessing data from decoding routines running in a multi-threaded
+ environment. Depending on the mode of operation it may contain the
+ actual data, may be connected to another #DataPool# or may be mapped
+ to a file. Regardless of the mode, the class returns data in a
+ thread-safe way, blocking reading threads if there is no data of
+ interest available. This blocking is especially useful in the
+ networking environment (plugin) when there is a running decoding thread,
+ which wants to start decoding as soon as there is just one byte available
+ blocking if necessary.
+
+ Access to data in a #DataPool# may be direct (Using \Ref{get_data}()
+ function) or sequential (See \Ref{get_stream}() function).
+
+ If the #DataPool# is not connected to anything, that is it contains
+ some real data, this data can be added to it by means of two
+ \Ref{add_data}() functions. One of them adds data sequentially maintaining
+ the offset of the last block of data added by it. The other can store
+ data anywhere. Thus it's important to realize, that there may be "white
+ spots" in the data storage.
+
+ There is also a way to test if data is available for some given data
+ range (See \Ref{has_data}()). In addition to this mechanism, there are
+ so-called {\em trigger callbacks}, which are called, when there is
+ all data available for a given data range.
+
+ Let us consider all modes of operation in details:
+
+ \begin{enumerate}
+ \item {\bf Not connected #DataPool#}. In this mode the #DataPool#
+ contains some real data. As mentioned above, it may be added
+ by means of two functions \Ref{add_data}() operating independent
+ of each other and allowing to add data sequentially and
+ directly to any place of data storage. It's important to call
+ function \Ref{set_eof}() after all data has been added.
+
+ Functions like \Ref{get_data}() or \Ref{get_stream}() can
+ be used to obtain direct or sequential access to the data. As
+ long as \Ref{is_eof}() is #FALSE#, #DataPool# will block every
+ reader, which is trying to read unavailable data until it
+ really becomes available. But as soon as \Ref{is_eof}() is
+ #TRUE#, any attempt to read non-existing data will read #0# bytes.
+
+ Taking into account the fact, that #DataPool# was designed to
+ store DjVu files, which are in IFF formats, it becomes possible
+ to predict the size of the #DataPool# as soon as the first
+ #32# bytes have been added. This is invaluable for estimating
+ download progress. See function \Ref{get_length}() for details.
+ If this estimate fails (which means, that stored data is not
+ in IFF format), \Ref{get_length}() returns #-1#.
+
+ Triggers may be added and removed by means of \Ref{add_trigger}()
+ and \Ref{del_trigger}() functions. \Ref{add_trigger}() takes
+ a data range. As soon as all data in that data range is
+ available, the trigger callback will be called.
+
+ All trigger callbacks will be called when #EOF# condition
+ has been set.
+
+ \item {\bf #DataPool# connected to another #DataPool#}. In this
+ {\em slave} mode you can map a given #DataPool# to any offsets
+ range inside another #DataPool#. You can connect the slave
+ #DataPool# even if there is no data in the master #DataPool#.
+ Any \Ref{get_data}() request will be forwarded to the master
+ #DataPool#, and it will be responsible for blocking readers
+ trying to access unavailable data.
+
+ The usage of \Ref{add_data}() functions is prohibited for
+ connected #DataPool#s.
+
+ The offsets range used to map a slave #DataPool# can be fully
+ specified (both start offset and length are positive numbers)
+ or partially specified (the length is negative). In this mode
+ the slave #DataPool# is assumed to extend up to the end
+ of the master #DataPool#.
+
+ Triggers may be used with slave #DataPool#s as well as with
+ the master ones.
+
+ Calling \Ref{stop}() function of a slave will stop only the slave
+ (and any other slave connected to it), but not the master.
+
+ \Ref{set_eof}() function is meaningless for slaves. They obtain
+ the #ByteStream::EndOfFile# status from their master.
+
+ Depending on the offsets range passed to the constructor,
+ \Ref{get_length}() returns different values. If the length
+ passed to the constructor was positive, then it is returned
+ by \Ref{get_length}() all the time. Otherwise the value returned
+ is either #-1# if master's length is still unknown (it didn't
+ manage to parse IFF data yet) or it is calculated as
+ #masters_length-slave_start#.
+
+ \item {\bf #DataPool# connected to a file}. This mode is quite similar
+ to the case, when the #DataPool# is connected to another
+ #DataPool#. Similarly, the #DataPool# stores no data inside.
+ It just forwards all \Ref{get_data}() requests to the underlying
+ source (a file in this case). Thus these requests will never
+ block the reader. But they may return #0# if there is no data
+ available at the requested offset.
+
+ The usage of \Ref{add_data}() functions is meaningless and
+ is prohibited.
+
+ \Ref{is_eof}() function always returns #TRUE#. Thus \Ref{set_eof}()
+ us meaningless and does nothing.
+
+ \Ref{get_length}() function always returns the file size.
+
+ Calling \Ref{stop}() function will stop this #DataPool# and
+ any other slave connected to it.
+
+ Trigger callbacks passed through \Ref{add_trigger}() function
+ are called immediately.
+
+ This mode is useful to read and decode DjVu files without reading
+ and storing them in full in memory.
+ \end{enumerate}
+*/
+
+class DataPool : public GPEnabled
+{
+public: // Classes used internally by DataPool
+ // These are declared public to support buggy C++ compilers.
+ class Incrementor;
+ class Reader;
+ class Trigger;
+ class OpenFiles;
+ class OpenFiles_File;
+ class BlockList;
+ class Counter;
+protected:
+ DataPool(void);
+
+public:
+ /** @name Initialization */
+ //@{
+ /** Default creator. Will prepare #DataPool# for accepting data
+ added through functions \Ref{add_data}(). Use \Ref{connect}()
+ functions if you want to map this #DataPool# to another or
+ to a file. */
+ static GP<DataPool> create(void);
+
+ /** Creates and initialized the #DataPool# with data from stream #str#.
+ The constructor will read the stream's contents and add them
+ to the pool using the \Ref{add_data}() function. Afterwards it
+ will call \Ref{set_eof}() function, and no other data will be
+ allowed to be added to the pool. */
+ static GP<DataPool> create(const GP<ByteStream> & str);
+
+ /** Initializes the #DataPool# in slave mode and connects it
+ to the specified offsets range of the specified master #DataPool#.
+ It is equivalent to calling default constructor and function
+ \Ref{connect}().
+
+ @param master_pool Master #DataPool# providing data for this slave
+ @param start Beginning of the offsets range which the slave is
+ mapped into
+ @param length Length of the offsets range. If negative, the range
+ is assumed to extend up to the end of the master #DataPool#.
+ */
+ static GP<DataPool> create(const GP<DataPool> & master_pool, int start=0, int length=-1);
+
+ /** Initializes the #DataPool# in slave mode and connects it
+ to the specified offsets range of the specified file.
+ It is equivalent to calling default constructor and function
+ \Ref{connect}().
+ @param url Name of the file to connect to.
+ @param start Beginning of the offsets range which the #DataPool# is
+ mapped into
+ @param length Length of the offsets range. If negative, the range
+ is assumed to extend up to the end of the file.
+ */
+ static GP<DataPool> create(const GURL &url, int start=0, int length=-1);
+
+ virtual ~DataPool();
+
+ /** Switches the #DataPool# to slave mode and connects it to the
+ specified offsets range of the master #DataPool#.
+ @param master_pool Master #DataPool# providing data for this slave
+ @param start Beginning of the offsets range which the slave is
+ mapped into
+ @param length Length of the offsets range. If negative, the range
+ is assumed to extend up to the end of the master #DataPool#.
+ */
+ void connect(const GP<DataPool> & master_pool, int start=0, int length=-1);
+ /** Connects the #DataPool# to the specified offsets range of
+ the named #url#.
+ @param url Name of the file to connect to.
+ @param start Beginning of the offsets range which the #DataPool# is
+ mapped into
+ @param length Length of the offsets range. If negative, the range
+ is assumed to extend up to the end of the file.
+ */
+ void connect(const GURL &url, int start=0, int length=-1);
+ //@}
+
+ /** Tells the #DataPool# to stop serving readers.
+
+ If #only_blocked# flag is #TRUE# then only those requests will
+ be processed, which would not block. Any attempt to get non-existing
+ data would result in a #STOP# exception (instead of blocking until
+ data is available).
+
+ If #only_blocked# flag is #FALSE# then any further attempt to read
+ from this #DataPool# (as well as from any #DataPool# connected
+ to this one) will result in a #STOP# exception. */
+ void stop(bool only_blocked=false);
+
+ /** @name Adding data.
+ Please note, that these functions are for not connected #DataPool#s
+ only. You can not add data to a #DataPool#, which is connected
+ to another #DataPool# or to a file.
+ */
+ //@{
+ /** Appends the new block of data to the #DataPool#. There are two
+ \Ref{add_data}() functions available. One is for adding data
+ sequentially. It keeps track of the last byte position, which has
+ been stored {\bf by it} and always appends the next block after
+ this position. The other \Ref{add_data}() can store data anywhere.
+
+ The function will unblock readers waiting for data if this data
+ arrives with this block. It may also trigger some {\em trigger
+ callbacks}, which may have been added by means of \Ref{add_trigger}()
+ function.
+
+ {\bf Note:} After all the data has been added, it's necessary
+ to call \Ref{set_eof}() to tell the #DataPool# that nothing else
+ is expected.
+
+ {\bf Note:} This function may not be called if the #DataPool#
+ has been connected to something.
+
+ @param buffer data to append
+ @param size length of the {\em buffer}
+ */
+ void add_data(const void * buffer, int size);
+
+ /** Stores the specified block of data at the specified offset.
+ Like the function above this one can also unblock readers
+ waiting for data and engage trigger callbacks. The difference
+ is that {\bf this} function can store data anywhere.
+
+ {\bf Note:} After all the data has been added, it's necessary
+ to call \Ref{set_eof}() to tell the #DataPool# that nothing else
+ is expected.
+
+ {\bf Note:} This function may not be called if the #DataPool#
+ has been connected to something.
+
+ @param buffer data to store
+ @param offset where to store the data
+ @param size length of the {\em buffer} */
+ void add_data(const void * buffer, int offset, int size);
+
+ /** Tells the #DataPool# that all data has been added and nothing else
+ is anticipated. When #EOF# is true, any reader attempting to read
+ non existing data will not be blocked. It will either read #ZERO#
+ bytes or will get an #ByteStream::EndOfFile# exception (see \Ref{get_data}()).
+ Calling this function will also activate all registered trigger
+ callbacks.
+
+ {\bf Note:} This function is meaningless and does nothing
+ when the #DataPool# is connected to another #DataPool# or to
+ a file. */
+ void set_eof(void);
+ //@}
+
+ /** @name Accessing data.
+ These functions provide direct and sequential access to the
+ data of the #DataPool#. If the #DataPool# is not connected
+ (contains some real data) then it handles the requests itself.
+ Otherwise they are forwarded to the master #DataPool# or the file.
+ */
+ //@{
+ /** Attempts to return a block of data at the given #offset#
+ of the given #size#.
+
+ \begin{enumerate}
+ \item If the #DataPool# is connected to another #DataPool# or
+ to a file, the request will just be forwarded to them.
+ \item If the #DataPool# is not connected to anything and
+ some of the data requested is in the internal buffer,
+ the function copies available data to #buffer# and returns
+ immediately.
+
+ If there is no data available, and \Ref{is_eof}() returns
+ #FALSE#, the reader (and the thread) will be {\bf blocked}
+ until the data actually arrives. Please note, that since
+ the reader is blocked, it should run in a separate thread
+ so that other threads have a chance to call \Ref{add_data}().
+ If there is no data available, but \Ref{is_eof}() is #TRUE#
+ the behavior is different and depends on the #DataPool#'s
+ estimate of the file size:
+ \begin{itemize}
+ \item If #DataPool# learns from the IFF structure of the
+ data, that its size should be greater than it
+ really is, then any attempt to read non-existing
+ data in the range of {\em valid} offsets will
+ result in an #ByteStream::EndOfFile# exception. This is done to
+ indicate, that there was an error in adding data,
+ and the data requested is {\bf supposed} to be
+ there, but has actually not been added.
+ \item If #DataPool#'s expectations about the data size
+ coincide with the reality then any attempt to
+ read data beyond the legal range of offsets will
+ result in #ZERO# bytes returned.
+ \end{itemize}.
+ \end{enumerate}.
+
+ @param buffer Buffer to be filled with data
+ @param offset Offset in the #DataPool# to read data at
+ @param size Size of the {\em buffer}
+ @return The number of bytes actually read
+ @exception STOP The stream has been stopped
+ @exception EOF The requested data is not there and will not be added,
+ although it should have been.
+ */
+ int get_data(void * buffer, int offset, int size);
+
+ /** Returns a \Ref{ByteStream} to access contents of the #DataPool#
+ sequentially. By reading from the returned stream you basically
+ call \Ref{get_data}() function. Thus, everything said for it
+ remains true for the stream too. */
+ GP<ByteStream> get_stream(void);
+ //@}
+
+ /** @name State querying functions. */
+ //@{
+ /** Returns #TRUE# if this #DataPool# is connected to another #DataPool#
+ or to a file. */
+ bool is_connected(void) const;
+
+ /** Returns #TRUE# if all data available for offsets from
+ #start# till #start+length-1#. If #length# is negative, the
+ range is assumed to extend up to the end of the #DataPool#.
+ This function works both for connected and not connected #DataPool#s.
+ Once it returned #TRUE# for some offsets range, you can be
+ sure that the subsequent \Ref{get_data}() request will not block.
+ */
+ bool has_data(int start, int length);
+
+ /* Returns #TRUE# if no more data is planned to be added.
+
+ {\bf Note:} This function always returns #TRUE# when the #DataPool#
+ has been initialized with a file name. */
+ bool is_eof(void) const {return eof_flag;}
+
+ /** Returns the {\em length} of data in the #DataPool#. The value
+ returned depends on the mode of operation:
+ \begin{itemize}
+ \item If the #DataPool# is not connected to anything then
+ the length returned is either calculated by interpreting
+ the IFF structure of stored data (if successful) or
+ by calculating the real size of data after \Ref{set_eof}()
+ has been called. Otherwise it is #-1#.
+ \item If the #DataPool# is connected to a file, the length
+ is calculated basing on the length passed to the
+ \Ref{connect}() function and the file size.
+ \item If the #DataPool# is connected to a master #DataPool#,
+ the length is calculated basing on the value returned
+ by the master's #get_length()# function and the length
+ passed to the \Ref{connect}() function.
+ \end{itemize}. */
+ int get_length(void) const;
+ /** Returns the number of bytes of data available in this #DataPool#.
+ Contrary to the \Ref{get_length}() function, this one doesn't try
+ to interpret the IFF structure and predict the file length.
+ It just returns the number of bytes of data really available inside
+ the #DataPool#, if it contains data, or inside its range, if it's
+ connected to another #DataPool# or a file. */
+ int get_size(void) const {return get_size(0, -1);}
+ //@}
+
+ /** @name Trigger callbacks.
+ {\em Trigger callbacks} are special callbacks called when
+ all data for the given range of offsets has been made available.
+ Since reading unavailable data may result in a thread block,
+ which may be bad, the usage of {\em trigger callbacks} appears
+ to be a convenient way to signal availability of data.
+
+ You can add a trigger callback in two ways:
+ \begin{enumerate}
+ \item By specifying a range. This is the most general case
+ \item By providing just one {\em threshold}. In this case
+ the range is assumed to start from offset #ZERO# and
+ last for {\em threshold}+1 bytes.
+ \end{enumerate}
+ */
+ //@{
+ /** Associates the specified {\em trigger callback} with the
+ given data range.
+
+ {\bf Note:} The callback may be called immediately if all
+ data for the given range is already available or #EOF# is #TRUE#.
+
+ @param start The beginning of the range for which all data
+ should be available
+ @param length If the {\em length} is not negative then the callback
+ will be called when there is data available for every
+ offset from {\em start} to {\em start+length-1}.
+ If {\em thresh} is negative, the callback is called after
+ #EOF# condition has been set.
+ @param callback Function to call
+ @param cl_data Argument to pass to the callback when it's called. */
+ void add_trigger(int start, int length,
+// void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data);
+ void (* callback)(void *), void * cl_data);
+
+ /** Associates the specified {\em trigger callback} with the
+ specified threshold.
+
+ This function is a simplified version of the function above.
+ The callback will be called when there is data available for
+ every offset from #0# to #thresh#, if #thresh# is positive, or
+ when #EOF# condition has been set otherwise. */
+// void add_trigger(int thresh, void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data);
+ void add_trigger(int thresh, void (* callback)(void *), void * cl_data);
+
+ /** Use this function to unregister callbacks, which are no longer
+ needed. {\bf Note!} It's important to do it when the client
+ is about to be destroyed. */
+ void del_trigger(void (* callback)(void *), void * cl_data);
+// void del_trigger(void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data);
+ //@}
+
+ /** Loads data from the file into memory. This function is only useful
+ for #DataPool#s getting data from a file. It descends the #DataPool#s
+ hierarchy until it either reaches a file-connected #DataPool#
+ or #DataPool# containing the real data. In the latter case it
+ does nothing, in the first case it makes the #DataPool# read all
+ data from the file into memory and stop using the file.
+
+ This may be useful when you want to overwrite the file and leave
+ existing #DataPool#s with valid data. */
+ void load_file(void);
+ /** This function will make every #DataPool# in the program, which
+ is connected to a file, to load the file contents to the main
+ memory and close the file. This feature is important when you
+ want to do something with the file like remove or overwrite it
+ not affecting the rest of the program. */
+ static void load_file(const GURL &url);
+
+ /** This function will remove OpenFiles filelist. */
+ static void close_all(void);
+
+ // Internal. Used by 'OpenFiles'
+ void clear_stream(const bool release = true);
+
+ /** Useful in comparing data pools. Returns true if dirived from
+ same URL or bytestream. */
+ bool simple_compare(DataPool &pool) const;
+private:
+ bool eof_flag;
+ bool stop_flag;
+ bool stop_blocked_flag;
+
+ Counter *active_readers;
+
+ // Source or storage of data
+ GP<DataPool> pool;
+ GURL furl;
+ GP<OpenFiles_File> fstream;
+ GCriticalSection class_stream_lock;
+ GP<ByteStream> data;
+ GCriticalSection data_lock;
+ BlockList *block_list;
+ int add_at;
+ int start, length;
+
+ // List of readers waiting for data
+ GPList<Reader> readers_list;
+ GCriticalSection readers_lock;
+
+ // Triggers
+ GPList<Trigger> triggers_list; // List of passed or our triggers
+ GCriticalSection triggers_lock; // Lock for the list above
+ GCriticalSection trigger_lock; // Lock for static_trigger_cb()
+
+ void init(void);
+ void wait_for_data(const GP<Reader> & reader);
+ void wake_up_all_readers(void);
+ void check_triggers(void);
+ int get_data(void * buffer, int offset, int size, int level);
+ int get_size(int start, int length) const;
+ void restart_readers(void);
+
+// static void static_trigger_cb(GP<GPEnabled> &);
+ static void static_trigger_cb(void *);
+ void trigger_cb(void);
+ void analyze_iff(void);
+ void added_data(const int offset, const int size);
+public:
+ static const char *Stop;
+ friend class FCPools;
+};
+
+inline bool
+DataPool::simple_compare(DataPool &pool) const
+{
+ // return true if these pools are identical. False means they may or may
+ // not be identical.
+ return (this == &pool)
+ ||(furl.is_valid()&&!furl.is_empty()&&pool.furl.is_valid()&&(furl == pool.furl))
+ ||(data && (data == pool.data));
+}
+
+inline bool
+DataPool::is_connected(void) const
+{
+ return furl.is_local_file_url() || pool!=0;
+}
+
+//@}
+
+
+#ifdef HAVE_NAMESPACES
+}
+# ifndef NOT_USING_DJVU_NAMESPACE
+using namespace DJVU;
+# endif
+#endif
+#endif