BlockStreamBuffer.h

Go to the documentation of this file.

#ifndef ossimBlockStreamBuffer_HEADER
#define ossimBlockStreamBuffer_HEADER 1
#include <ossim/base/ossimIosFwd.h>
#include <ossim/base/ossimConstants.h>
#include <iostream>
#include <vector>

namespace ossim{
   class OSSIM_DLL BlockBufInfo{
   public:
      BlockBufInfo():
      m_startByte(0),
      m_blockSize(0),
      m_validSize(0),         
      m_blockBufferPtr(0),
      m_blockLoaded(false){

      }

      ossim_int64 getBlockIndex(ossim_int64 pos){
         ossim_int64 result = -1;
         if(m_blockSize&&m_blockBufferPtr&&(pos>=0))
         {
            result = pos/m_blockSize;
         }

         return result;
      }

      bool isWithinWindow(ossim_int64 pos)const{
         return  (m_blockLoaded&&
                  (pos>=m_startByte)&&
                  (pos<(m_startByte+m_blockSize)));
      }

      bool isWithinValidWindow(ossim_int64 pos)const{
         return  (m_blockLoaded&&
                  (pos>=m_startByte)&&
                  (pos<getEndByte()));
      }

      ossim_int64 getEndByte()const{
         if(m_validSize>=0) return m_startByte+(m_validSize);
         return m_startByte;
      }

      const char* getBufferStart(ossim_int64 absolutePosition)const{
         if(isWithinValidWindow(absolutePosition))
         {
            return m_blockBufferPtr+(absolutePosition-m_startByte);
         }

         return 0;
      }

      const char* getBuffer()const{
         return m_blockBufferPtr;
      }

      char* getBuffer(){
         return m_blockBufferPtr;
      }

      bool isLoaded()const{return m_blockLoaded;}

      void setBuffer(char* bufPtr, ossim_uint32 blockSize)
      {
         m_blockBufferPtr = bufPtr;
         m_blockSize      = blockSize;
         m_blockLoaded    = false;
      }

      ossim_int64 m_startByte;

      ossim_int64 m_blockSize;

      ossim_int64 m_validSize;

      char* m_blockBufferPtr;

      bool m_blockLoaded;
   };

   class OSSIM_DLL BlockStreamBuffer : public std::streambuf{
   public:
      BlockStreamBuffer(ossim::istream* adaptStream=0, ossim_uint64 blockSize=0);
      virtual ~BlockStreamBuffer(){
         m_adaptStream=0;
      }
   protected:
      std::vector<char> m_blockBuffer;

      ossim_int64 m_currentPosValue;

      BlockBufInfo m_blockInfo;

      ossim::istream* m_adaptStream;

   virtual std::streambuf* setbuf (char* s, std::streamsize n);

      void setgPtrs();

      void loadBlock();

      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);

      virtual pos_type seekpos(pos_type pos,
                               std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);

      virtual std::streamsize xsgetn(char_type* s, std::streamsize n);
      
      virtual int underflow();

      void syncCurrentPosition();
   };
}
#endif