Category : OS/2 Files
Archive   : GPPDEV8F.ZIP
Filename : FPLEX.HP

// This may look like C code, but it is really -*- C++ -*-
/*
Copyright (C) 1988 Free Software Foundation
written by Doug Lea ([email protected])
based on code by Marc Shapiro ([email protected])

This file is part of the GNU C++ Library. This library is free
software; you can redistribute it and/or modify it under the terms of
the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version. 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 Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef _FPlex_h
#ifdef __GNUG__
#pragma interface
#endif
#define _FPlex_h 1

#include ".Plex.h"

class FPlex : public Plex
{
public:
FPlex(); // set low = 0;
// fence = 0;
// csize = default

FPlex(int maxsize); // low = 0;
// fence = 0;
// csize = maxsize

FPlex(int lo, // low = lo;
int maxsize); // fence=lo
// csize = maxsize

FPlex(int lo, // low = lo
int hi, // fence = hi+1
const initval,// fill with initval,
int maxsize = 0); // csize = maxsize
// or fence - lo if 0

FPlex(const FPlex&); // X(X&)

~FPlex();

void operator= (const FPlex&);

// virtuals

& high_element ();
& low_element ();

const & high_element () const;
const & low_element () const;

Pix first() const;
Pix last() const;
void prev(Pix& ptr) const;
void next(Pix& ptr) const;
int owns(Pix p) const;
& operator () (Pix p);
const & operator () (Pix p) const;

int low() const;
int high() const;
int valid(int idx) const;
void prev(int& idx) const;
void next(int& x) const;
& operator [] (int index);
const & operator [] (int index) const;

int Pix_to_index(Pix p) const;
Pix index_to_Pix(int idx) const;

int can_add_high() const;
int can_add_low() const;
int full() const;

int add_high(const elem);
int del_high ();
int add_low (const elem);
int del_low ();

void fill(const x);
void fill(const x, int from, int to);
void clear();
void reverse();

int OK () const;
};


inline int FPlex::valid (int idx) const
{
return idx >= lo && idx < fnc;
}

inline int FPlex::low() const
{
return lo;
}

inline int FPlex::high() const
{
return fnc - 1;
}

inline Pix FPlex::first() const
{
return (Pix)(hd->IChunk::first_pointer());
}

inline void FPlex::prev(Pix& p) const
{
p = Pix(hd->IChunk::pred((*) p));
}

inline void FPlex::next(Pix& p) const
{
p = Pix(hd->IChunk::succ((*) p));
}

inline Pix FPlex::last() const
{
return Pix(hd->IChunk::last_pointer());
}

inline int FPlex::full () const
{
return fnc - lo == csize;
}

inline void FPlex::prev(int& idx) const
{
--idx;
}

inline void FPlex::next(int& idx) const
{
++idx;
}

inline & FPlex:: operator [] (int idx)
{
if (idx < lo || idx >= fnc) index_error();
return *(hd->pointer_to(idx));
}

inline & FPlex:: operator () (Pix p)
{
return *((*)p);
}

inline & FPlex::low_element ()
{
if (empty()) index_error();
return *(hd->pointer_to(lo));
}

inline & FPlex::high_element ()
{
if (empty()) index_error();
return *(hd->pointer_to(fnc - 1));
}

inline const & FPlex:: operator [] (int idx) const
{
if (idx < lo || idx >= fnc) index_error();
return *(hd->pointer_to(idx));
}

inline const & FPlex:: operator () (Pix p) const
{
return *((const *)p);
}

inline const & FPlex::low_element () const
{
if (empty()) index_error();
return *(hd->pointer_to(lo));
}

inline const & FPlex::high_element () const
{
if (empty()) index_error();
return *(hd->pointer_to(fnc - 1));
}

inline int FPlex::can_add_high() const
{
return hd->can_grow_high();
}

inline int FPlex::can_add_low() const
{
return hd->can_grow_low();
}

inline int FPlex::add_high(const elem)
{
if (!can_add_high()) full_error();
*((hd->IChunk::grow_high())) = elem;
return fnc++;
}

inline int FPlex::del_high ()
{
if (empty()) empty_error();
hd->IChunk::shrink_high();
return --fnc - 1;
}

inline int FPlex::add_low (const elem)
{
if (!can_add_low()) full_error();
*((hd->IChunk::grow_low())) = elem;
return --lo;
}

inline int FPlex::del_low ()
{
if (empty()) empty_error();
hd->IChunk::shrink_low();
return ++lo;
}

inline int FPlex::owns (Pix p) const
{
return hd->actual_pointer((*)p);
}

inline int FPlex::Pix_to_index(Pix p) const
{
if (!hd->actual_pointer((const *)p)) index_error();
return hd->index_of((const *)p);
}

inline Pix FPlex::index_to_Pix(int idx) const
{
if (idx < lo || idx >= fnc) index_error();
return Pix(hd->pointer_to(idx));
}

inline FPlex::~FPlex() {}

#endif