ossim::BlockStreamBuffer Class Reference

This is the BlockStreamBuffer class and derives from stream buf. More...

#include <BlockStreamBuffer.h>

Inheritance diagram for ossim::BlockStreamBuffer:

Public Member Functions
	BlockStreamBuffer (ossim::istream *adaptStream=0, ossim_uint64 blockSize=0)
virtual	~BlockStreamBuffer ()

Protected Member Functions
virtual std::streambuf *	setbuf (char *s, std::streamsize n)
	This is a virtual method that can be overriden. More...
void	setgPtrs ()
	setgPtrs calls setg and sets the eback egptr and gptr. More...
void	loadBlock ()
	loadBlock will load data into the current block and call the setgPtrs to adjust the internal pointers tha the base streambuf may use More...
virtual pos_type	seekoff (off_type offset, std::ios_base::seekdir dir, std::ios_base::openmode mode=std::ios_base::in|std::ios_base::out)
	this is a protected method overriden from streambuf base. More...
virtual pos_type	seekpos (pos_type pos, std::ios_base::openmode mode=std::ios_base::in|std::ios_base::out)
	seekpos is overriden from the base streambuf class. More...
virtual std::streamsize	xsgetn (char_type *s, std::streamsize n)
	xsgetn is a protected virtual method that we override from the base streambuf. More...
virtual int	underflow ()
	underflow is overriden from the base streambuf. More...
void	syncCurrentPosition ()
	syncCurrentPosition is a utility method that we call internally in the overriden protected methods that will sync the location of the gptr to the absolute byte offset variable we are using internally. More...

Protected Attributes
std::vector< char >	m_blockBuffer
	The block buffer that we set the buf pointers to. More...
ossim_int64	m_currentPosValue
	holds the current absolute byte position More...
BlockBufInfo	m_blockInfo
	Holds the information about the block. More...
ossim::istream *	m_adaptStream
	The stream we are adapting. More...

Detailed Description

This is the BlockStreamBuffer class and derives from stream buf.

This class

Definition at line 168 of file BlockStreamBuffer.h.

Constructor & Destructor Documentation

BlockStreamBuffer()

ossim::BlockStreamBuffer::BlockStreamBuffer	(	ossim::istream *	adaptStream = 0,
		ossim_uint64	blockSize = 0
	)

Definition at line 7 of file BlockStreamBuffer.cpp.

References m_blockBuffer, ossim::BlockBufInfo::m_blockBufferPtr, m_blockInfo, and ossim::BlockBufInfo::m_blockSize.

   :  m_blockBuffer(),
      m_currentPosValue(0),
      m_blockInfo(),
      m_adaptStream(adaptStream)
{
   m_blockInfo.m_blockSize = blockSize;
   if(m_blockInfo.m_blockSize)
   {
      m_blockBuffer.resize(m_blockInfo.m_blockSize);
      m_blockInfo.m_blockBufferPtr = &m_blockBuffer.front();
   }
   setg(0, 0, 0);
}

~BlockStreamBuffer()

virtual ossim::BlockStreamBuffer::~BlockStreamBuffer ( )

inlinevirtual

Definition at line 171 of file BlockStreamBuffer.h.

                                  {
         m_adaptStream=0;
      }

Member Function Documentation

loadBlock()

void ossim::BlockStreamBuffer::loadBlock ( )

protected

loadBlock will load data into the current block and call the setgPtrs to adjust the internal pointers tha the base streambuf may use

Definition at line 49 of file BlockStreamBuffer.cpp.

{
   m_blockInfo.m_blockLoaded = false;
   m_blockInfo.m_validSize = 0;
   if(m_adaptStream)
   {
      if(m_currentPosValue < 0) m_currentPosValue = 0;
      ossim_int64 blockIndex = m_blockInfo.getBlockIndex(m_currentPosValue);
      m_blockInfo.m_startByte = blockIndex*m_blockInfo.m_blockSize;
      if(!m_adaptStream->good()) m_adaptStream->clear();
      if(m_blockInfo.m_startByte != m_adaptStream->tellg())
      {
         m_adaptStream->seekg(m_blockInfo.m_startByte);
      }
      m_adaptStream->read(m_blockInfo.m_blockBufferPtr, 
                          m_blockInfo.m_blockSize);
      ossim_int64 bytesRead = m_adaptStream->gcount();
      if(!m_adaptStream->bad()&&(bytesRead>0))
      {
         m_blockInfo.m_blockLoaded = true;
         m_blockInfo.m_validSize = bytesRead;
         if((m_blockInfo.m_validSize<=0)||(!m_blockInfo.isWithinValidWindow(m_currentPosValue)))
         {
            m_blockInfo.m_blockLoaded = false;
         }
      }
   }
   setgPtrs();
}

seekoff()

std::streambuf::pos_type ossim::BlockStreamBuffer::seekoff ( off_type  offset, std::ios_base::seekdir  dir, std::ios_base::openmode  mode = std::ios_base::in | std::ios_base::out  )

protectedvirtual

this is a protected method overriden from streambuf base.

we will convert the offset byte to an absolute if we can and then call the seek pos for the absolute seek

Definition at line 79 of file BlockStreamBuffer.cpp.

{
   // make sure we are in synch with current pos
   // gptr can be updated by other means
   syncCurrentPosition();
   pos_type result = pos_type(off_type(-1));
   if(m_adaptStream)
   {
      ossim_int64 pos = m_currentPosValue;
      switch(dir)
      {
         case std::ios_base::beg:
         {
            pos = offset;
            result = seekpos(pos, std::ios_base::in);
            break;
         }
         case std::ios_base::cur:
         {
            pos += offset;
            result = seekpos(pos, std::ios_base::in);
           break;
         }
         case std::ios_base::end:
         {
            // at this point in time of implementation
            // we do not know the offset to the end of the stream
            // we are adapting
            //
            // we have no choice but to call the adapted stream
            // implementation
            result = m_adaptStream->rdbuf()->pubseekoff(pos, dir);
            m_currentPosValue = result;
            setgPtrs();

            break;
         }
         default:
         {
            break;
         }
      }
   }
   return result;
}

seekpos()

std::streambuf::pos_type ossim::BlockStreamBuffer::seekpos ( pos_type  pos, std::ios_base::openmode  mode = std::ios_base::in | std::ios_base::out  )

protectedvirtual

seekpos is overriden from the base streambuf class.

This is the seek of the aboslute position. We will check to see if the new position resides in the block and if so we just update our pointers and return the pos. If bnot then we use the adapted stream call to seek to the position and update our internal pointers.

Parameters

pos	The absolute position to seek to the mode used. Should be in

Returns

The absolute position if successful or EOF if not.

Definition at line 126 of file BlockStreamBuffer.cpp.

{
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::seekpos DEBUG: entered with absolute position: " << pos << "\n";
   }
   pos_type result = pos_type(off_type(-1));

   if(m_adaptStream)
   {
      if(pos == m_currentPosValue)
      {
         result = pos;
      }
      else if(m_blockInfo.isLoaded()&&m_blockInfo.isWithinValidWindow(pos))
      {
         result = pos;
         m_currentPosValue = result;
      }
      else
      {
         result = m_adaptStream->rdbuf()->pubseekpos(pos, mode);
         m_currentPosValue = result;
      }
      setgPtrs();
   }

   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::seekpos DEBUG: leaving\n";

   }
   return result;

}

setbuf()

std::streambuf * ossim::BlockStreamBuffer::setbuf ( char *  s, std::streamsize  n  )

protectedvirtual

This is a virtual method that can be overriden.

pubsetbuf can be called and calls this protected method to set a buffer.

Parameters

s	The starting address of a byte buffer
n	The size of the buffer

Definition at line 22 of file BlockStreamBuffer.cpp.

References n.

{
   if(n>0)
   {
      m_blockBuffer.clear();
      m_blockInfo.setBuffer(s,n);
      setg(0, 0, 0);
   }
   return this;
}

setgPtrs()

void ossim::BlockStreamBuffer::setgPtrs ( )

protected

setgPtrs calls setg and sets the eback egptr and gptr.

to the managed buffer's valid window

Definition at line 34 of file BlockStreamBuffer.cpp.

{
   if(m_blockInfo.isLoaded())
   {
      setg(m_blockInfo.getBuffer(),
           m_blockInfo.getBuffer() + (m_currentPosValue - m_blockInfo.m_startByte),
           m_blockInfo.getBuffer() + m_blockInfo.m_validSize);
   }
   else
   {
      setg(0,0,0);
   }

}

syncCurrentPosition()

void ossim::BlockStreamBuffer::syncCurrentPosition ( )

protected

syncCurrentPosition is a utility method that we call internally in the overriden protected methods that will sync the location of the gptr to the absolute byte offset variable we are using internally.

The problem is, when things like ignore(...) peek(...) and other options are used on an input stream the base might adjust the gptr location. When this is adjusted outside our control the offsets might get out of sync this is called to ensure this does not happen

Definition at line 261 of file BlockStreamBuffer.cpp.

{
   if(m_blockInfo.isLoaded()&&gptr())
   {
      m_currentPosValue = (m_blockInfo.m_startByte+(gptr()-eback()));
   } 
}

underflow()

int ossim::BlockStreamBuffer::underflow ( )

protectedvirtual

underflow is overriden from the base streambuf.

It check to see if the current block is loaded and if not load the block. The method returns what is currently pointed to by the absolute offset or basically return *gptr().

Returns

the current byte we are pointing to.

Definition at line 231 of file BlockStreamBuffer.cpp.

{
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::underflow DEBUG: entered ......\n";

   }
   if(!m_adaptStream) return EOF;
   else{
      syncCurrentPosition();
      if(!m_blockInfo.isWithinValidWindow(m_currentPosValue))
      {
         loadBlock();
      }

      if(!m_blockInfo.isLoaded())
      {
         return EOF;
      }
   } 
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::underflow DEBUG: leaving ......\n";

   }
   return (int)static_cast<ossim_uint8>(*gptr());
}

xsgetn()

std::streamsize ossim::BlockStreamBuffer::xsgetn ( char_type *  s, std::streamsize  n  )

protectedvirtual

xsgetn is a protected virtual method that we override from the base streambuf.

The method will load blocks of data to service the requested buffer to fill. If the request covers several block it will iterate and load each block of data until the request is satisfied.

Parameters

s	The destination buffer large enough to hold the characters being requested
n	The number of characters to request from the input stream

Returns

The number of bytes read or -1 if failed

Definition at line 165 of file BlockStreamBuffer.cpp.

{
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::xsgetn DEBUG: entered ......"<<n<<"\n";

   }
   std::streamsize result = EOF;

   if(m_adaptStream)
   {
      ossim_int64 bytesNeedToRead = n;
      ossim_int64 bytesRead = 0;
      syncCurrentPosition();

      while(bytesNeedToRead>0)
      {
         if(!m_blockInfo.isWithinValidWindow(m_currentPosValue))
         {
            loadBlock();
         }

         if(m_blockInfo.isLoaded())
         {
            ossim_int64 delta = (m_blockInfo.getEndByte()-
                                 m_currentPosValue);
            if(delta <= bytesNeedToRead)
            {
               std::memcpy(s+bytesRead,
                           m_blockInfo.getBufferStart(m_currentPosValue),
                           delta);
               bytesRead+=delta;
               bytesNeedToRead-=delta;
               m_currentPosValue+=delta;
            }
            else
            {
               std::memcpy(s+bytesRead,
                           m_blockInfo.getBufferStart(m_currentPosValue),
                           bytesNeedToRead);
               m_currentPosValue+=bytesNeedToRead;
               bytesRead+=bytesNeedToRead;
               bytesNeedToRead=0;
            }
         }
         else
         {
            bytesNeedToRead=0;
         }
      }
      // specify the current absolute position after read
      // so we are in sync.
      setgPtrs();
      result = bytesRead;
   }
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "BlockStreamBuffer::xsgetn DEBUG: leaving ......\n";

   }
   return result;
}

Member Data Documentation

m_adaptStream

ossim::istream* ossim::BlockStreamBuffer::m_adaptStream

protected

The stream we are adapting.

Definition at line 195 of file BlockStreamBuffer.h.

m_blockBuffer

std::vector<char> ossim::BlockStreamBuffer::m_blockBuffer

protected

The block buffer that we set the buf pointers to.

Definition at line 178 of file BlockStreamBuffer.h.

Referenced by BlockStreamBuffer().

m_blockInfo

BlockBufInfo ossim::BlockStreamBuffer::m_blockInfo

protected

Holds the information about the block.

It tells us if the block is currently loaded and what the valid size is

Definition at line 190 of file BlockStreamBuffer.h.

Referenced by BlockStreamBuffer().

m_currentPosValue

ossim_int64 ossim::BlockStreamBuffer::m_currentPosValue

protected

holds the current absolute byte position

Definition at line 183 of file BlockStreamBuffer.h.

---

The documentation for this class was generated from the following files:

• BlockStreamBuffer.h
• BlockStreamBuffer.cpp