// This may look like C code, but it is really -*- C++ -*- /* Copyright (C) 1988 Free Software Foundation written by Doug Lea (dl@rocky.oswego.edu) based on code by Marc Shapiro (shapiro@sor.inria.fr) This file is part of GNU CC. GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU CC General Public License for full details. Everyone is granted permission to copy, modify and redistribute GNU CC, but only under the conditions described in the GNU CC General Public License. A copy of this license is supposed to have been given to you along with GNU CC so you can know your rights and responsibilities. It should be in a file named COPYING. Among other things, the copyright notice and this notice must be preserved on all copies. */ #ifndef _FPlex_h #ifdef __GNUG__ #pragma once #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(); void append(const FPlex& a); void prepend(const FPlex& a); int OK () const; }; #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES) 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 #endif