1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/***************************************************************************
kplainbuffer.h - description
-------------------
begin : Mit Jun 03 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_KPLAINBUFFER_H
#define KHE_KPLAINBUFFER_H
#include "kdatabuffer.h"
namespace KHE
{
/*
class KPlainBufferIterator : public KDataBufferIterator
{
}
*/
/** 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?
*@author Friedrich W. H. Kossebau
*/
class KPlainBuffer : public KDataBuffer
{
friend class KPlainBufferIterator;
public:
KPlainBuffer( char *D, unsigned int S, int RS = -1, bool KM = true );
KPlainBuffer( const char *D, unsigned int S );
KPlainBuffer( int S=0, int MS = -1 );
virtual ~KPlainBuffer();
public: // KDataBuffer API
virtual bool prepareRange( KSection Range ) const;
//virtual KDataBufferIterator *iterator() const;
virtual const char *dataSet( KSection S ) const;
virtual char datum( unsigned int Offset ) const;
virtual int size() const;
virtual bool isReadOnly() const;
virtual bool isModified() const;
virtual int insert( int Pos, const char*, int Length );
virtual int remove( KSection Remove );
virtual unsigned int tqreplace( KSection Remove, const char*, unsigned int InputLength );
virtual int move( int DestPos, KSection SourceSection );
virtual int fill( const char FillChar, int Length = -1, unsigned int Pos = 0 );
virtual void setDatum( unsigned int Offset, const char Char );
virtual void setModified( bool M = true );
//virtual int tqfind( const char*, int Length, int Pos = 0 ) const;
virtual int tqfind( const char*KeyData, int Length, KSection Section ) const;
virtual int rfind( const char*, int Length, int Pos = -1 ) const;
/* virtual int tqfind( const TQString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */
public:
void setReadOnly( bool RO = true );
void setMaxSize( int MS );
/** sets whether the memory given by setData or in the constructor should be kept on resize
*/
void setKeepsMemory( bool KM = true );
public:
char *data() const;
int maxSize() const;
/** returns whether the memory of the byte array is kept */
bool keepsMemory() const;
protected:
/** resizes the buffer, if possible, saving the data and splitting the data, if demanded
* @param AddSize additional size the buffer should grow
* @param SplitPos if -1 does not split
* @param SaveUpperPart true if upper part should be copied into new buffer
* @return additional size the buffer has grown
*/
int addSize( int AddSize, int SplitPos = -1, bool SaveUpperPart = true );
protected:
/** */
char *Data;
/** size of the data */
unsigned int Size;
/** Size of data array */
unsigned int RawSize;
/** maximal size of array, unlimited if -1 */
int MaxSize;
/** flag whether the initially given memory should be kept */
bool KeepsMemory:1;
/** */
bool ReadOnly:1;
/** */
bool Modified:1;
};
inline bool KPlainBuffer::prepareRange( KSection ) const { return true; }
inline const char *KPlainBuffer::dataSet( KSection S ) const { return &Data[S.start()]; }
inline char KPlainBuffer::datum( unsigned int Offset ) const { return Data[Offset]; }
inline int KPlainBuffer::size() const { return Size; }
inline bool KPlainBuffer::isReadOnly() const { return ReadOnly; }
inline bool KPlainBuffer::isModified() const { return Modified; }
inline void KPlainBuffer::setDatum( unsigned int Offset, const char Char )
{ Data[Offset] = Char; Modified = true; }
inline void KPlainBuffer::setReadOnly( bool RO ) { ReadOnly = RO; }
inline void KPlainBuffer::setModified( bool M ) { Modified = M; }
inline void KPlainBuffer::setMaxSize( int MS ) { MaxSize = MS; }
inline void KPlainBuffer::setKeepsMemory( bool KM ) { KeepsMemory = KM; }
inline char *KPlainBuffer::data() const { return Data; }
inline int KPlainBuffer::maxSize() const { return MaxSize; }
inline bool KPlainBuffer::keepsMemory() const { return KeepsMemory; }
}
#endif
|
