abstractbytearraymodel.h

Go to the documentation of this file.

/*
    This file is part of the Okteta Core library, made within the KDE community.

    Copyright 2003,2008-2009 Friedrich W. H. Kossebau <kossebau@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) version 3, or any
    later version accepted by the membership of KDE e.V. (or its
    successor approved by the membership of KDE e.V.), which shall
    act as a proxy defined in Section 6 of version 3 of the license.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OKTETA_ABSTRACTBYTEARRAYMODEL_H
#define OKTETA_ABSTRACTBYTEARRAYMODEL_H

// lib
#include "oktetacore_export.h"
#include "addressrange.h"
#include "size.h"
#include "byte.h"
// Qt
#include <QtCore/QObject>
#include <QtCore/QByteArray>


namespace Okteta
{

class ArrayChangeMetricsList;
class CharCodec;


class OKTETACORE_EXPORT AbstractByteArrayModel : public QObject
{
  friend class KAbstractByteArrayModelIterator;

  Q_OBJECT

  protected:
    explicit AbstractByteArrayModel( QObject* parent = 0 );
  public:
    virtual ~AbstractByteArrayModel();


  public: // data access API
    //virtual bool prepareRange( const Section &Range ) const = 0;
    //bool prepareRange( int Offset, int Length ) const;

    //virtual KDataBufferIterator *iterator() const = 0;
    //virtual const char *dataSet( const Section &Section ) const = 0;
    //const char *dataSet( int Offset, int Length ) const;

    virtual Byte byte( Address offset ) const = 0;

    virtual Size size() const = 0;


  public: // state read API
    virtual bool isReadOnly() const;
    virtual bool isModified() const = 0;

// TODO: for data outside the model using char* and int as well as QByteArray should always work, no?
  public: // modification API
    virtual Size insert( Address offset, const Byte* insertData, int insertLength );
    Size insert( Address offset, const QByteArray& insertData );

    virtual Size remove( const AddressRange& removeRange );
    Size remove( Address offset, Size removeLength );

    virtual Size replace( const AddressRange& removeRange, const Byte* insertData, int insertLength ) = 0;
    Size replace( const AddressRange& removeRange, const QByteArray& insertData );
    Size replace( Address offset, Size removeLength,
                  const Byte* insertData, Size insertLength );

    // todo use parameters grouped differrently?
    virtual bool swap( Address firstStart, const AddressRange& secondRange ) = 0;

    virtual Size fill( Byte fillByte, Address offset = 0, Size fillLength = -1 ) = 0;
    Size fill( Byte fillChar, const AddressRange& fillRange );

    virtual void setByte( Address offset, Byte byte ) = 0;

    virtual void setModified( bool modified ) = 0;

    virtual void setReadOnly( bool isReadOnly );


  public: // service functions
    virtual Size copyTo( Byte* dest, const AddressRange& copyRange ) const;
    Size copyTo( Byte* dest, Address offset, Size copyLength ) const;


  public: // finding API
    virtual Address indexOf( const Byte* pattern, int patternLength, Address fromOffset = 0, Address toOffset = -1 ) const;
    Address indexOf( const QByteArray& pattern, Address fromOffset = 0, Address toOffset = -1 ) const;
    Address indexOfCaseInsensitive( const CharCodec* charCodec, const QByteArray& pattern, Address fromOffset = 0, Address toOffset = -1 ) const;

//     virtual int indexOf( const char*KeyData, int Length, const Section &Section ) const { return -1; }//= 0;
    virtual Address lastIndexOf( const Byte* pattern, int patternLength, Address fromOffset = -1, Address toOffset = 0 ) const;
    Address lastIndexOf( const QByteArray& pattern, Address fromOffset = -1, Address toOffset = 0 ) const;
    Address lastIndexOfCaseInsensitive( const CharCodec* charCodec, const QByteArray& pattern, Address fromOffset = -1, Address toOffset = 0 ) const;

/*     virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */

  Q_SIGNALS:
    // TODO: how to deal replacing with fixed size of buffer?
    void contentsChanged( const Okteta::ArrayChangeMetricsList& changeList );

    void readOnlyChanged( bool isReadOnly );
    void modifiedChanged( bool isModified );

    // TODO: how to handle a typedef with signals
    void searchedBytes( Okteta::Size bytes ) const;
};

// TODO: find why static_cast fails
inline Size AbstractByteArrayModel::insert( Address offset, const QByteArray& insertData )
{ return insert( offset, reinterpret_cast<const Byte*>(insertData.constData()), insertData.size() ); }

inline Size AbstractByteArrayModel::remove( Address offset, Size removeLength )
{ return remove( AddressRange::fromWidth(offset,removeLength) ); }

inline Size AbstractByteArrayModel::replace( const AddressRange& removeRange, const QByteArray& insertData )
{ return replace( removeRange, reinterpret_cast<const Byte*>(insertData.constData()), insertData.size() );}

inline Size AbstractByteArrayModel::replace( Address offset, Size removeLength,
                                             const Byte* insertData, Size insertLength )
{ return replace( AddressRange::fromWidth(offset,removeLength), insertData, insertLength ); }

inline Size AbstractByteArrayModel::fill( const Byte fillChar, const AddressRange& fillRange )
{ return fill( fillChar, fillRange.start(), fillRange.width() ); }

inline Size AbstractByteArrayModel::copyTo( Byte* dest, Address offset, Size copyLength ) const
{ return copyTo( dest, AddressRange::fromWidth(offset,copyLength) ); }

inline Address AbstractByteArrayModel::indexOf( const QByteArray& pattern, Address fromOffset, Address toOffset ) const
{ return indexOf( reinterpret_cast<const Byte*>(pattern.constData()), pattern.size(), fromOffset, toOffset ); }

inline Address AbstractByteArrayModel::lastIndexOf( const QByteArray& pattern, Address fromOffset, Address toOffset ) const
{ return lastIndexOf( reinterpret_cast<const Byte*>(pattern.constData()), pattern.size(), fromOffset, toOffset ); }

}

#endif