Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: array.h Sprache: C

Original von: Lyx^©

// -*- C++ -*-
/*
*  File:        array.h
*  Purpose:     A general purpose resizable array.
*  Author:      Alejandro Aguilar Sierra <[email protected]>
*  Created:     January 1996
*
*  Dependencies: None (almost)
*
*  Copyright: (c) 1996, Alejandro Aguilar Sierra
*                 1997  The LyX Team!
*
*   You are free to use and modify this code under the terms of
*   the GNU General Public Licence version 2 or later.
*/

#include <string.h>

#ifndef byte
#define byte unsigned char
#endif

/*@Doc: A resizable array
  Why is it called "LyXArrayBase" if it is generic? (Lgb)
  Initially I thought it could be the base class for both mathed's
  and LyX' kernels data buffer. (Ale)

  */
class LyxArrayBase  {
public:
///
enum {
  ///
  ARRAY_SIZE = 256,
  ///
  ARRAY_STEP = 16,
  ///
  ARRAY_MIN_SIZE = 4
};

///
LyxArrayBase(int size=ARRAY_STEP);
///
LyxArrayBase(const LyxArrayBase&);
///
~LyxArrayBase();


///
int Empty() { return (last==0); }

///
int Last() { return last; }

/// Fills with 0 the entire array and set last to 0
void Init();

/// Make the allocated memory fit the needed size
void Fit();

/// Remove dx elements from position pos. Don't changes the size
void Remove(int pos, int dx);

/// Merge dx elements from array a at pos. Changes the size if necessary.
void Merge(LyxArrayBase *a, int pos, int dx);

/// Same as Merge but doesn't changes the size (dangerous)
void MergeF(LyxArrayBase *a, int pos, int dx);

/// Copy dx byts from an array at position pos
void Copy(void *, int pos, int dx);

/// Constructs a new array with dx elements starting at pos
LyxArrayBase* Extract(int pos, int dx);

/// Insert a character at position pos
void Insert(int pos, byte);

/// Insert a string of lenght dx at position pos
void Insert(int pos, byte *, int dx);

/// Constructs a new array with dx elements starting at pos
byte operator[](const int);

/// Constructs a new array with dx elements starting at pos
LyxArrayBase& operator=(const LyxArrayBase&);

protected:
///
void Resize(int newsize);
///
bool Move(int p, int shift);

/// Buffer
byte *bf;
/// Last position inserted.
int last;
/// Max size of the array.
int maxsize;
private:
///
friend class MathedIter;
};


/************************ Inline functions *****************************/

inline
void LyxArrayBase::Init()
{
memset(bf, 0, maxsize);
last = 0;
}

inline // Hmmm, Hp-UX's CC can't handle this inline. Asger.
void LyxArrayBase::Resize(int newsize)
{
if (newsize<ARRAY_MIN_SIZE)
  newsize = ARRAY_MIN_SIZE;
newsize += ARRAY_STEP - (newsize % ARRAY_STEP);
byte *nwbf = new byte[newsize];
if (last >= newsize) last = newsize-1;
maxsize = newsize;
memcpy(nwbf, bf, last);
delete[] bf;
bf = nwbf;
bf[last] = 0;
}

inline
LyxArrayBase::LyxArrayBase(int size)
{
maxsize = (size<ARRAY_MIN_SIZE) ? ARRAY_MIN_SIZE: size;
bf = new byte[maxsize]; // this leaks
Init();
}

inline
LyxArrayBase::~LyxArrayBase()
{
delete[] bf;
}

inline
LyxArrayBase::LyxArrayBase(const LyxArrayBase& a)
{
maxsize = a.maxsize;
bf = new byte[maxsize];
memcpy(&bf[0], &a.bf[0], maxsize);
last = a.last;
}

inline
LyxArrayBase& LyxArrayBase::operator=(const LyxArrayBase& a)
{
if (this != &a) {
  Resize(a.maxsize);
  memcpy(&bf[0], &a.bf[0], maxsize);
}
return *this;
}

inline
bool LyxArrayBase::Move(int p, int shift)
{
bool result = false;
if (p<=last) {
  if (last+shift>=maxsize) {
      Resize(last + shift);
  }
  memmove(&bf[p+shift], &bf[p], last-p);
  last += shift;
  bf[last] = 0;
  result = true;
}
return result;
}

inline
void LyxArrayBase::Fit()
{
Resize(last);
}

inline
void LyxArrayBase::Remove(int pos, int dx)
{
Move(pos+dx, -dx);
}

inline
void LyxArrayBase::Merge(LyxArrayBase *a, int p, int dx)
{
Move(p, dx);
memcpy(&bf[p], &a->bf[0], dx);
}

inline
void LyxArrayBase::MergeF(LyxArrayBase *a, int p, int dx)
{
memcpy(&bf[p], &a->bf[0], dx);
}

inline
void LyxArrayBase::Copy(void *a, int p, int dx)
{
memcpy(&bf[p], a, dx);
}

inline
LyxArrayBase *LyxArrayBase::Extract(int, int dx)
{
LyxArrayBase *a = new LyxArrayBase(dx);
a->Merge(this, 0, dx);
return a;
}

inline
byte LyxArrayBase::operator[](const int i)
{
return bf[i];
}

inline
void LyxArrayBase::Insert(int pos, byte c)
{
if (pos<0) pos = last;
if (pos>=maxsize)
  Resize(maxsize+ARRAY_STEP);
bf[pos] = c;
if (pos>=last)
  last = pos+1;
}

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.