Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/GAP/pkg/fining/examples/gap/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 27.6.2023 mit Größe 12 B

SSL array.h Sprache: C

// -*- C++ -*-
/*
*  File:        array.h
*  Purpose:     A general purpose resizable array.
*  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
*  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;
}

quality100%

¤ Dauer der Verarbeitung: 0.11 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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.