diff options
Diffstat (limited to 'khexedit/lib/kdatabuffer.h')
| -rw-r--r-- | khexedit/lib/kdatabuffer.h | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/khexedit/lib/kdatabuffer.h b/khexedit/lib/kdatabuffer.h new file mode 100644 index 0000000..e9733d8 --- /dev/null +++ b/khexedit/lib/kdatabuffer.h @@ -0,0 +1,246 @@ +/*************************************************************************** + kdatabuffer.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KDATABUFFER_H +#define KHE_KDATABUFFER_H + + +// lib specific +#include "ksection.h" +#include "khexedit_export.h" + +namespace KHE +{ + +/** could it be useful to hide the data access behind an iterator? * +class KDataBufferIterator +{ + public: + bool hasNext(); + char next(); + protected: + + protected: + char * + int Length; +} + +bool KDataBufferIterator::hasNext() +{ +} +// this function should be simple as possible +char KDataBufferIterator::next() +{ + // if next span is empty + if( ) + return *NextChar++; +} +*/ +/** base class for all Data buffers that are used to display + * TODO: think about a way to inform KHexEdit that there has been + * a change in the buffer outside. what kind of changes are possible? + * + * Operations on the data: + * + * Finding: is implemented stateless. FindNext has to be done by perhaps a FindManager + * Replacing: not available. Implement within a ReplaceManager + * + *@author Friedrich W. H. Kossebau + */ + +class KHEXEDIT_EXPORT KDataBuffer +{ + friend class KDataBufferIterator; + + + protected: + KDataBuffer(); + public: + virtual ~KDataBuffer(); + + + public: // data access API + /** locates working range + * The idea behind is to tell buffer which range will be requested in the following time, + * so that e.g. the corresponding pages will be loaded in advance + * TODO: do we really need this? Where will this lead to real enhancements? + * @param Range + * @return @c true if successfull, @c false otherwise + */ + virtual bool prepareRange( KSection Range ) const = 0; + /** convenience function, same as above */ + bool prepareRange( int Offset, int Length ) const; + + /** creates an iterator to */ + //virtual KDataBufferIterator *iterator() const = 0; + /** expects pointer to memory, should be in prepared range + * it is only expected to be a valid pointer until any further call + * to this or any modifying function + * @param Section + * @return pointer to + */ + virtual const char *dataSet( KSection Section ) const = 0; + /** convenience function, same as above */ + const char *dataSet( int Offset, int Length ) const; + + /** requests a single byte + * if the offset is not valid the behaviout is undefined + * @param Offset offset of the datum requested + */ + virtual char datum( unsigned int Offset ) const = 0; + + /** + * @return the size of the data + */ + virtual int size() const = 0; + + + public: // state read API + /** + * @return @c true if the buffer can only be read, @c false if writing is allowed + */ + virtual bool isReadOnly() const; + /** + * @return @c true if the buffer has been modified, @c false otherwise + */ + virtual bool isModified() const = 0; + + + public: // modification API + /** inserts bytes copied from the given source at Position. + * The original data beginnung at the position is moved + * with the buffer enlarged as needed + * If the buffer is readOnly this is a noop and returns 0. + * @param Pos + * @param Source data source + * @param SourceLength number of bytes to copy + * @return length of inserted data + */ + virtual int insert( int Pos, const char* Source, int SourceLength ); + + /** removes beginning with position as much as possible + * @param Section + * @return length of removed data + */ + virtual int remove( KSection Section ); + /** convenience function, behaves as above */ + int remove( int Pos, int Length ); + + /** replaces as much as possible + * @param DestSection + * @param Source + * @param SourceLength + * @return length of replacced data + */ + virtual unsigned int replace( KSection DestSection, const char* Source, unsigned int SourceLength ) = 0; + /** convenience function, behaves as above */ + unsigned int replace( unsigned int Pos, unsigned int RemoveLength, + const char* Source, unsigned int SourceLength ); + + /** moves a part of the data to a new position, while floating the other data around + * when moving to a higher place the length of the block must be taken into account + * if the new positions extend beyond the buffers end the section is moved to the end. + * @param DesPos position of the data where the section should be moved behind + * @param SourceSection data section to be moved + * @return new pos of moved data or old, if failed + */ + virtual int move( int DestPos, KSection SourceSection ) = 0; + + /** + * fills the buffer with the FillChar. If the buffer is to small it will be extended as much as possible. + * @param FillChar char to use + * @param Length number of chars to fill. If Length is -1, the current buffer length is used. + * @param Pos position where the filling starts + * @return number of filled characters + */ + virtual int fill( const char FillChar, int Length = -1, unsigned int Pos = 0 ) = 0; + + /** sets a single byte + * if the offset is not valid the behaviour is undefined + * @param Offset offset of the datum requested + * @param Char new byte value + */ + virtual void setDatum( unsigned int Offset, const char Char ) = 0; + + /** sets the modified flag for the buffer + * @param M + */ + virtual void setModified( bool M ) = 0; + + + public: // service functions + /** copies the data of the section into a given array Dest. If the section extends the buffers range + * the section is limited to the buffer's end. If the section is invalid the behaviour is undefined. + * @param Dest pointer to a char array large enough to hold the copied section + * @param Source + * @return number of copied bytes + */ + virtual int copyTo( char* Dest, KSection Source ) const; + /** convenience function, behaves as above */ + int copyTo( char* Dest, int Pos, int n ) const; + + + public: // finding API + /** searches beginning with byte at Pos. + * @param + * @param Length length of search string + * @param Pos the position to start the search + * @return index of the first or -1 + */ + //virtual int find( const char*, int Length, int Pos = 0 ) const = 0; + /** searches for a given data string + * The section limits the data within which the key has to be found + * If the end of the section is lower then the start the search continues at the start??? + * @param + * @param Length length of search string + * @param Section section within the keydata is to be found + * @return index of the first occurence or -1 + */ + virtual int find( const char*KeyData, int Length, KSection Section ) const = 0; + /** searches backward beginning with byte at Pos. + * @param + * @param Length length of search string + * @param Pos the position to start the search. If -1 the search starts at the end. + * @return index of the first or -1 + */ + virtual int rfind( const char*, int Length, int Pos = -1 ) const = 0; + +/* virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */ +}; + + +inline KDataBuffer::KDataBuffer() {} +inline KDataBuffer::~KDataBuffer() {} + +inline bool KDataBuffer::prepareRange( int Offset, int Length ) const +{ return prepareRange( KSection(Offset,Offset+Length-1) ); } + +inline const char *KDataBuffer::dataSet( int Offset, int Length ) const +{ return dataSet( KSection(Offset,Offset+Length-1) ); } + +inline int KDataBuffer::remove( int Pos, int Length ) +{ return remove( KSection(Pos,Pos+Length-1) ); } + +inline unsigned int KDataBuffer::replace( unsigned int Pos, unsigned int RemoveLength, + const char* D, unsigned int InputLength ) +{ return replace( KSection(Pos,Pos+RemoveLength-1), D, InputLength ); } + +inline bool KDataBuffer::isReadOnly() const { return false; } + +} + +#endif |