Dream 52/Amiga_Dream_52.iso/Linux/Divers/lyx-0.13.2.tar.gz/lyx-0.13.2.tar/lyx-0.13.2/src/array.h

C/C++ Source or Header | 1998-04-23 | 4KB | 236 lines

// -*- C++ -*-
/*
 *  File:        array.h
 *  Purpose:     A general purpose resizable array.
 *  Author:      Alejandro Aguilar Sierra <[e-mail]>
 *  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;
}