//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, either Version 2 of the license,

//C- or (at your option) any later version. 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 from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.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, either Version 2 of the license,

//C- | or (at your option) any later version. 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- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "DataPool.h"

#include "IFFByteStream.h"

#include "GString.h"

#include "GOS.h"

#include "GURL.h"

#include "debug.h"

#ifndef macintosh

# include <sys/types.h>

#endif

#ifdef HAVE_NAMESPACES

namespace DJVU {

# ifdef NOT_DEFINED // Just to fool emacs c++ mode

}

#endif

#endif

const char * DataPool::Stop = ERR_MSG("STOP");

static void

// call_callback(void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data)

call_callback(void (* callback)(void *), void *cl_data)

{

   G_TRY

   {

      if (callback)

        callback(cl_data);

   } G_CATCH_ALL {} G_ENDCATCH;

}

//****************************************************************************

//****************************** OpenFiles ***********************************

//****************************************************************************

#define MAX_OPEN_FILES	15

/** The purpose of this class is to limit the number of files open by

    connected DataPools. Now, when a DataPool is connected to a file, it

    doesn't necessarily has it open. Every time it needs access to data

    it's supposed to ask this file for the ByteStream. It should

    also inform the class when it's going to die (so that the file can

    be closed). OpenFiles makes sure, that the number of open files

    doesn't exceed MAX_OPEN_FILES. When it does, it looks for the oldest

    file, closes it and asks all DataPools working with it to ZERO

    their GP<> pointers. */

class DataPool::OpenFiles_File : public GPEnabled

{

public:

  GURL			url;

  GP<ByteStream>	        stream;		// Stream connected to 'url'

  GCriticalSection		stream_lock;

  GPList<DataPool>		pools_list;	// List of pools using this stream

  GCriticalSection		pools_lock;

  unsigned long		open_time;	// Time when stream was open

  int	add_pool(GP<DataPool> &pool);

  int	del_pool(GP<DataPool> &pool);

  OpenFiles_File(const GURL &url, GP<DataPool> &pool);

  virtual ~OpenFiles_File(void);

  void clear_stream(void);

};

class DataPool::OpenFiles : public GPEnabled

{

private:

   static OpenFiles	* global_ptr;

   GPList<DataPool::OpenFiles_File>		files_list;

   GCriticalSection	files_lock;

public:

   static OpenFiles	* get(void);

      // Opend the specified file if necessary (or finds an already open one)

      // and returns it. The caller (pool) is stored in the list associated

      // with the stream. Whenever OpenFiles decides, that this stream

      // had better be closed, it will order every pool from the list to

      // ZERO their references to it

   GP<DataPool::OpenFiles_File> request_stream(const GURL &url, GP<DataPool> pool);

      // If there are more than MAX_STREAM_FILES open, close the oldest.

   void		prune(void);

      // Removes the pool from the list associated with the stream.

      // If there is nobody else using this stream, the stream will

      // be closed too.

   void		stream_released(GP<ByteStream> &stream, GP<DataPool> pool);

   void 	close_all(void);

};

DataPool::OpenFiles * DataPool::OpenFiles::global_ptr;

DataPool::OpenFiles_File::OpenFiles_File(const GURL &xurl, GP<DataPool> &pool) : url(xurl)

{

   DEBUG_MSG("DataPool::OpenFiles_File::OpenFiles_File(): Opening file '" << url << "'\n");

   DEBUG_MAKE_INDENT(3);

   open_time=GOS::ticks();

   stream=ByteStream::create(url,"rb");

   add_pool(pool);

}

DataPool::OpenFiles_File::~OpenFiles_File(void)

{

   DEBUG_MSG("DataPool::OpenFiles_File::~OpenFiles_File(): Closing file '" << url << "'\n");

   DEBUG_MAKE_INDENT(3);

   clear_stream();

}

void

DataPool::OpenFiles_File::clear_stream(void)

{

  GCriticalSectionLock lock(&pools_lock);

  for(GPosition pos=pools_list;pos;++pos)

    if(pools_list[pos])

      pools_list[pos]->clear_stream(false);

  pools_list.empty();

}

int

DataPool::OpenFiles_File::add_pool(GP<DataPool> &pool)

{

   DEBUG_MSG("DataPool::OpenFiles_File::add_pool: pool=" << (void *) pool << "\n");

   DEBUG_MAKE_INDENT(3);

   GCriticalSectionLock lock(&pools_lock);

   if (!pools_list.contains(pool))

     pools_list.append(pool);

   return pools_list.size();

}

int

DataPool::OpenFiles_File::del_pool(GP<DataPool> &pool)

{

   DEBUG_MSG("DataPool::OpenFiles_File::del_pool: pool=" << (void *) pool << "\n");

   DEBUG_MAKE_INDENT(3);

   GCriticalSectionLock lock(&pools_lock);

   GPosition pos;

   if (pools_list.search(pool, pos))

     pools_list.del(pos);

   return pools_list.size();

}

inline DataPool::OpenFiles *

DataPool::OpenFiles::get(void)

{

   DEBUG_MSG("DataPool::OpenFiles::get()\n");

   DEBUG_MAKE_INDENT(3);

   if (!global_ptr)

     global_ptr=new OpenFiles();

   return global_ptr;

}

void

DataPool::OpenFiles::prune(void)

{

  DEBUG_MSG("DataPool::OpenFiles::prune(void): "<

  DEBUG_MAKE_INDENT(3);

  while(files_list.size()>MAX_OPEN_FILES)

    {

      // Too many open files (streams). Get rid of the oldest one.

      unsigned long oldest_time=GOS::ticks();

      GPosition oldest_pos=files_list;

      for(GPosition pos=files_list;pos;++pos)

        {

          if (files_list[pos]->open_time

            {

              oldest_time=files_list[pos]->open_time;

              oldest_pos=pos;

            }

        }

      files_list[oldest_pos]->clear_stream();

      files_list.del(oldest_pos);

    }

}

//			  GP<ByteStream> & stream,

//			  GCriticalSection ** stream_lock)

GP<DataPool::OpenFiles_File>

DataPool::OpenFiles::request_stream(const GURL &url, GP<DataPool> pool)

{

   DEBUG_MSG("DataPool::OpenFiles::request_stream(): url='" << url << "'\n");

   DEBUG_MAKE_INDENT(3);

   GP<DataPool::OpenFiles_File> file;

      // Check: maybe the stream has already been open by request of

      // another DataPool

   GCriticalSectionLock lock(&files_lock);

   for(GPosition pos=files_list;pos;++pos)

   {

      if (files_list[pos]->url==url)

      {

	 DEBUG_MSG("found existing stream\n");

	 file=files_list[pos];

	 break;

      }

   }

      // No? Open the stream, but check, that there are not

      // too many streams open

   if (!file)

   {

      file=new DataPool::OpenFiles_File(url, pool);

      files_list.append(file);

      prune();

   }

   file->add_pool(pool);

   return file;

}

void

DataPool::OpenFiles::stream_released(GP<ByteStream> &stream, GP<DataPool> pool)

{

   DEBUG_MSG("DataPool::OpenFiles::stream_release: stream=" 

             << (void *)stream << " pool=" << (void *)pool << "\n");

   DEBUG_MAKE_INDENT(3);

   GCriticalSectionLock lock(&files_lock);

   for(GPosition pos=files_list;pos;)

   {

     GPosition dpos = pos;

     ++pos;

     GP<DataPool::OpenFiles_File> f=files_list[dpos];

     if ((ByteStream *)(f->stream) == (ByteStream *)stream)

       if (f->del_pool(pool)==0)

         files_list.del(dpos);

   }

}

// This isn't really an accurate url.  The files are not really

// closed.  Instead they are dereferenced from the data pool.  If

// a there is another reference to the respective bytestream, it

// will remain open until dereferenced.

void

DataPool::OpenFiles::close_all(void)

{

  DEBUG_MSG("DataPool::OpenFiles::close_all\n");

  DEBUG_MAKE_INDENT(3);

  GCriticalSectionLock lock(&files_lock);

  files_list.empty();

}

//****************************************************************************

//******************************** FCPools ***********************************

//****************************************************************************

/** This class is used to maintain a list of DataPools connected to a file.

    It's important to have this list if we want to do something with this file

    like to modify it or just erase. Since any modifications of the file

    will break DataPools directly connected to it, it would be nice to have

    a mechanism for signaling all the related DataPools to read data into

    memory. This is precisely the purpose of this class. */

class FCPools

{

private:

   GMap<GURL, GPList<DataPool> >	map;	// GMap<GUTF8String, GPList<DataPool>> in fact

   GCriticalSection		map_lock;

   static FCPools	* global_ptr;

public:

   static FCPools *	get(void);

      // Adds the <furl, pool> pair into the list

   void		add_pool(const GURL &furl, GP<DataPool> pool);

      // Removes the <furl, pool> pair from the list

   void		del_pool(const GURL &furl, GP<DataPool> pool);

      // Looks for the list of DataPools connected to 'furl' and makes

      // each of them load the contents of the file into memory

   void		load_file(const GURL &url;;

      // Retrieve a local URL, if available.

   GP<DataPool> get_pool(const GURL &url, int start, int length);

   void clean(void);

};

void

FCPools::clean(void)

{

  GCriticalSectionLock lock(&map_lock);

  static int count=0;

  if(! count++)

  {

    bool restart = true;

    while (restart)

      {

        restart = false;

        for (GPosition posmap = map; posmap; ++posmap)

          {

            GPList<DataPool> *lst;

            lst = & map[posmap];

            if (lst->isempty())

              {

                map.del(posmap);

                restart = true;

                break;

              }

            for (GPosition poslst = *lst; poslst; ++poslst)

              if ((*lst)[poslst]->get_count() < 2) 

                {

                  lst->del(poslst);

                  restart = true;

                  break;

                }

            if (restart)

              break;

          }

      }

  }

  --count;

}

void

FCPools::add_pool(const GURL &url, GP<DataPool> pool)

{

  DEBUG_MSG("FCPools::add_pool: url='" << url << "' pool=" << (void *)pool << "\n");

  DEBUG_MAKE_INDENT(3);

  GCriticalSectionLock lock(&map_lock);

   if (url.is_local_file_url())

   {

      GPList<DataPool> list;

      GPosition pos(map.contains(url));

      if (! pos)

      {

        map[url]=list;

        pos=map.contains(url);

      }

      GPList<DataPool> &plist=map[pos];

      if (!plist.contains(pool))

        plist.append(pool);

   }

  clean();

}

GP<DataPool>

FCPools::get_pool(const GURL &url, int start, int length)

{

  DEBUG_MSG("FCPools::get_pool: url='" << url << "\n");

  DEBUG_MAKE_INDENT(3);

  GP<DataPool> retval;

  if (url.is_local_file_url())

  {

    GCriticalSectionLock lock(&map_lock);

    GPosition pos(map.contains(url));

    if (pos)

    {

      GPList<DataPool> &plist=map[pos];

      for(pos=plist;pos;++pos)

      {

        DataPool &pool=*plist[pos];

        if(start == pool.start && (length < 0 || (length == pool.length)))

        {

          retval=plist[pos];

          break;

        }

      }

    }

    clean();

  }

  return retval;

}

void

FCPools::del_pool(const GURL &url, GP<DataPool> pool)

{

  DEBUG_MSG("FCPools::del_pool: url='" << url << "' pool=" << (void *)pool << "\n");

  DEBUG_MAKE_INDENT(3);

  GCriticalSectionLock lock(&map_lock);

  clean();

   if (url.is_local_file_url())

   {

      GPosition pos;

      if (map.contains(url, pos))

      {

	 GPList<DataPool> &list=map[pos];

	 GPosition list_pos;

	 while(list.search(pool, list_pos))

	    list.del(list_pos);

	 if (list.isempty())

	 {

	    map.del(pos);

	 }

      }

   }

}

void

FCPools::load_file(const GURL &url)

{

  DEBUG_MSG("FCPools::load_file: url='" << url << "'\n");

  DEBUG_MAKE_INDENT(3);

  GCriticalSectionLock lock(&map_lock);

  clean();

   if (url.is_local_file_url())

   {

      GPosition pos;

      if (map.contains(url, pos))

      {

	    // We make here a copy of the list because DataPool::load_file()

	    // will call FCPools::del_pool(), which will modify the list

	 GPList<DataPool> list=map[pos];

	 for(GPosition list_pos=list;list_pos;++list_pos)

	    list[list_pos]->load_file();

      }

   }

}

FCPools	* FCPools::global_ptr;

inline FCPools *

FCPools::get(void)

{

   if (!global_ptr)

     global_ptr=new FCPools();

   return global_ptr;

}

//****************************************************************************

//****************************** BlockList ***********************************

//****************************************************************************

// Since data can be added to the DataPool at any offset now, there may

// be white spots, which contain illegal data. This class is to contain

// the list of valid and invalid regions.

// The class is basically a list of integers. Abs(integer)=size of the

// block. If the integer is positive, data for the block is known.

// Otherwise it's unkown.

class DataPool::BlockList

{

         // See comments in .cpp file.

private:

   GCriticalSection  lock;

   GList<int>        list;

public:

   BlockList() {};

   void              clear(void);

   void              add_range(int start, int length);

   int               get_bytes(int start, int length) const;

   int               get_range(int start, int length) const;

friend class DataPool;

};

void

DataPool::BlockList::clear(void)

{

  DEBUG_MSG("DataPool::BlockList::clear()\n");

  DEBUG_MAKE_INDENT(3);

   GCriticalSectionLock lk(&lock);

   list.empty();

}

void

DataPool::BlockList::add_range(int start, int length)

      // Adds range of known data.

{

  DEBUG_MSG("DataPool::BlockList::add_range: start=" << start << " length=" << length << "\n");

  DEBUG_MAKE_INDENT(3);

   if (start<0)

     G_THROW( ERR_MSG("DataPool.neg_start") );

   if (length<=0)

     G_THROW( ERR_MSG("DataPool.bad_length") );

   if (length>0)

   {

      GCriticalSectionLock lk(&lock);

	 // Look thru existing zones, change their sign and split if

	 // necessary.

      GPosition pos=list;

      int block_start=0, block_end=0;

      while(pos && block_start

      {

	 int size=list[pos];

	 block_end=block_start+abs(size);

	 if (size<0)

	   {

	     if (block_start

	       {

		 if (block_end>start && block_end<=start+length)

		   {

		     list[pos]=-(start-block_start);

		     list.insert_after(pos, block_end-start);

		     ++pos;

		     block_start=start;

		   } else if (block_end>start+length)

		   {

		     list[pos]=-(start-block_start);

		     list.insert_after(pos, length);

		     ++pos;

		     list.insert_after(pos, -(block_end-(start+length)));

		     ++pos;

		     block_start=start+length;

		   }

	       } else if (block_start>=start && block_start

	       {

		 if (block_end<=start+length) list[pos]=abs(size);

		 else

		   {

		     list[pos]=start+length-block_start;

		     list.insert_after(pos, -(block_end-(start+length)));

		     ++pos;

		     block_start=start+length;

		   }

	       }

	   }

	 block_start=block_end;

	 ++pos;

      }

      if (block_end

      {

	 list.append(-(start-block_end));

	 list.append(length);

      } else if (block_end

	 // Now merge adjacent areas with the same sign

      pos=list;

      while(pos)

      {

	 GPosition pos1=pos; ++pos1;

	 while(pos1)

	   {

	     if ( (list[pos]<0 && list[pos1]>0) ||

		  (list[pos]>0 && list[pos1]<0) )

	       break;

	     list[pos]+=list[pos1];

	     GPosition this_pos=pos1;

	     ++pos1;

	     list.del(this_pos);

	   }

	 pos=pos1;

      }

   } // if (length>0)

}

int

DataPool::BlockList::get_bytes(int start, int length) const

      // Returns the number of bytes of data available in the range

      // [start, start+length[. There may be holes between data chunks

{

  DEBUG_MSG("DataPool::BlockList::get_bytes: start=" << start << " length=" << length << "\n");

  DEBUG_MAKE_INDENT(3);

   if (length<0)

     G_THROW( ERR_MSG("DataPool.bad_length") );

   GCriticalSectionLock lk((GCriticalSection *) &lock);

   int bytes=0;

   int block_start=0, block_end=0;

   for(GPosition pos=list;pos && block_start

   {

      int size=list[pos];

      block_end=block_start+abs(size);

      if (size>0)

	{

	  if (block_start

	    {

	      if (block_end>=start && block_end

		bytes+=block_end-start;

	      else if (block_end>=start+length)

		bytes+=length;

	    }

	  else

	    {

	      if (block_end<=start+length)

		bytes+=block_end-block_start;

	      else bytes+=start+length-block_start;

	    }

	}

      block_start=block_end;

   }

   return bytes;

}

int

DataPool::BlockList::get_range(int start, int length) const

      // Finds a range covering offset=start and returns the length

      // of intersection of this range with [start, start+length[

      // 0 is returned if nothing can be found

{

  DEBUG_MSG("DataPool::BlockList::get_range: start=" << start << " length=" << length << "\n");

  DEBUG_MAKE_INDENT(3);

   if (start<0)

     G_THROW( ERR_MSG("DataPool.neg_start") );

   if (length<=0)

      G_THROW( ERR_MSG("DataPool.bad_length") );

   GCriticalSectionLock lk((GCriticalSection *) &lock);

   int block_start=0, block_end=0;

   for(GPosition pos=list;pos && block_start

     {

       int size=list[pos];

       block_end=block_start+abs(size);

       if (block_start<=start && block_end>start)

	 {

	   if (size<0)

	     return -1;

	   else if (block_end>start+length)

	     return length;

	   else

	     return block_end-start;

	 }

       block_start=block_end;

     }

   return 0;

}

//****************************************************************************

//******************************* DataPool ***********************************

//****************************************************************************

class DataPool::Reader : public GPEnabled

{

public:

   GEvent event;

   bool reenter_flag;

   int  offset;

   int  size;

   Reader() : reenter_flag(false), offset(0), size(-1){};

   Reader(int offset_in, int size_in=-1) :

   reenter_flag(false), offset(offset_in), size(size_in) {};

   virtual ~Reader() {};

};

class DataPool::Trigger : public GPEnabled

{

public:

   GSafeFlags disabled;

   int  start, length;

//   void (* callback)(GP<GPEnabled> &);

   void (* callback)(void *);

//   GP<GPEnabled> cl_data;

   void *cl_data;

   Trigger() : start(0), length(-1), callback(0), cl_data(0) {};

   Trigger(int xstart, int xlength,

//   void (* xcallback)(GP<GPEnabled> &), GP<GPEnabled> xcl_data) :

   void (* xcallback)(void *), void *xcl_data) :

      start(xstart), length(xlength), callback(xcallback), cl_data(xcl_data) {};

   virtual ~Trigger() {};

};

class DataPool::Counter

{

private:

   int               counter;

   GCriticalSection  lock;

public:

   Counter() : counter(0) {};

   operator int(void) const;

   void              inc(void);

   void              dec(void);

};

#define DATAPOOL_INIT eof_flag(false),stop_flag(false), \

    stop_blocked_flag(false), \

    add_at(0),start(0),length(-1)

void

DataPool::init(void)

{

  DEBUG_MSG("DataPool::init(): Initializing\n");

  DEBUG_MAKE_INDENT(3);

  start=0; length=-1; add_at=0;

  eof_flag=false;

  stop_flag=false;

  stop_blocked_flag=false;

  active_readers=new Counter;

  block_list=0;

  G_TRY

  {   

    block_list=new BlockList;

    data=ByteStream::create();

  }

  G_CATCH_ALL

  {

    delete block_list;

    block_list=0;

    delete active_readers;

    active_readers=0;

    G_RETHROW;

  }

  G_ENDCATCH;

}

DataPool::DataPool(void) : DATAPOOL_INIT {}

GP<DataPool>

DataPool::create(void)

{

  DEBUG_MSG("DataPool::DataPool()\n");

  DEBUG_MAKE_INDENT(3);

  DataPool *pool=new DataPool();

  GP<DataPool> retval=pool;

  pool->init();

      // If we maintain the data ourselves, we want to interpret its

      // IFF structure to predict its length

  pool->add_trigger(0, 32, static_trigger_cb, pool);

  return retval;

}

GP<DataPool> 

DataPool::create(const GP<ByteStream> &gstr)

{

  DEBUG_MSG("DataPool::create: str="<<(ByteStream *)gstr<<"\n");

  DEBUG_MAKE_INDENT(3);

  DataPool *pool=new DataPool();

  GP<DataPool> retval=pool;

  pool->init();

  // It's nice to have IFF data analyzed in this case too.

  pool->add_trigger(0, 32, static_trigger_cb, pool);

  char buffer[1024];

  int length;

  while((length=gstr->read(buffer, 1024)))

    pool->add_data(buffer, length);

  pool->set_eof();

  return retval;

}

GP<DataPool>

DataPool::create(const GP<DataPool> & pool, int start, int length)

{

  DEBUG_MSG("DataPool::DataPool: pool=" << (void *)((DataPool *)pool) << " start=" << start << " length= " << length << "\n");

  DEBUG_MAKE_INDENT(3);

  DataPool *xpool=new DataPool();

  GP<DataPool> retval=xpool;

  xpool->init();

  xpool->connect(pool, start, length);

  return retval;

}

GP<DataPool>

DataPool::create(const GURL &furl, int start, int length)

{

  DEBUG_MSG("DataPool::DataPool: furl='" << furl << "' start=" << start << " length= " << length << "\n");

  DEBUG_MAKE_INDENT(3);

  GP<DataPool> retval=FCPools::get()->get_pool(furl,start,length);

  if(! retval)

  {

    DataPool *pool=new DataPool();

    retval=pool;

    pool->init();

    pool->connect(furl, start, length);

  }

  return retval;

}

void

DataPool::clear_stream(const bool release)

{

  DEBUG_MSG("DataPool::clear_stream()\n");

  DEBUG_MAKE_INDENT(3);

  if(fstream)

  {

    GCriticalSectionLock lock1(&class_stream_lock);

    GP<OpenFiles_File> f=fstream;

    if(f)

    {

      GCriticalSectionLock lock2(&(f->stream_lock));

      fstream=0;

      if(release)

        OpenFiles::get()->stream_released(f->stream, this);

    }

  }

}

DataPool::~DataPool(void)

{

  DEBUG_MSG("DataPool::~DataPool()\n");

  DEBUG_MAKE_INDENT(3);

  clear_stream(true);

  if (furl.is_local_file_url())

    if (this->get_count() > 1)

      FCPools::get()->del_pool(furl, this);

  GP<DataPool> pool = this->pool;

  {

	 // Wait until the static_trigger_cb() exits

      GCriticalSectionLock lock(&trigger_lock);

      if (pool)

        pool->del_trigger(static_trigger_cb, this);

      del_trigger(static_trigger_cb, this);

  }

  if (pool)

  {

      GCriticalSectionLock lock(&triggers_lock);

      for(GPosition pos=triggers_list;pos;++pos)

      {

	 GP<Trigger> trigger=triggers_list[pos];

	 pool->del_trigger(trigger->callback, trigger->cl_data);

      }

  }

  delete block_list;

  delete active_readers;

}

void

DataPool::connect(const GP<DataPool> & pool_in, int start_in, int length_in)

{

   DEBUG_MSG("DataPool::connect(): connecting to another DataPool\n");

   DEBUG_MAKE_INDENT(3);

   if (pool) G_THROW( ERR_MSG("DataPool.connected1") );

   if (furl.is_local_file_url()) G_THROW( ERR_MSG("DataPool.connected2") );

   if (start_in<0) G_THROW( ERR_MSG("DataPool.neg_start") );

   pool=pool_in;

   start=start_in;

   length=length_in;