// 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 _XPlex_h #ifdef __GNUG__ #pragma once #pragma interface #endif #define _XPlex_h 1 #include ".Plex.h" class XPlex: public Plex { IChunk* ch; // cached chunk void make_initial_chunks(int up = 1); void cache(int idx) const; void cache(const * p) const; * dopred(const * p) const; * dosucc(const * p) const; void set_cache(const IChunk* t) const; // logically, // not physically const public: XPlex(); // set low = 0; // fence = 0; // csize = default XPlex(int ch_size); // low = 0; // fence = 0; // csize = ch_size XPlex(int lo, // low = lo; int ch_size); // fence=lo // csize = ch_size XPlex(int lo, // low = lo int hi, // fence = hi+1 const initval,// fill with initval, int ch_size = 0); // csize= ch_size // or fence-lo if 0 XPlex(const XPlex&); void operator= (const XPlex&); // 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 XPlex& a); void prepend(const XPlex& a); int OK () const; }; #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES) inline void XPlex::prev(int& idx) const { --idx; } inline void XPlex::next(int& idx) const { ++idx; } inline int XPlex::full () const { return 0; } inline int XPlex::can_add_high() const { return 1; } inline int XPlex::can_add_low() const { return 1; } inline int XPlex::valid (int idx) const { return idx >= lo && idx < fnc; } inline int XPlex::low() const { return lo; } inline int XPlex::high() const { return fnc - 1; } inline & XPlex:: operator [] (int idx) { if (!ch->actual_index(idx)) cache(idx); return *(ch->pointer_to(idx)); } inline const & XPlex:: operator [] (int idx) const { if (!ch->actual_index(idx)) cache(idx); return *((const *)(ch->pointer_to(idx))); } inline & XPlex::low_element () { if (empty()) index_error(); return *(hd->pointer_to(lo)); } inline const & XPlex::low_element () const { if (empty()) index_error(); return *((const *)(hd->pointer_to(lo))); } inline & XPlex::high_element () { if (empty()) index_error(); return *(tl()->pointer_to(fnc - 1)); } inline const & XPlex::high_element () const { if (empty()) index_error(); return *((const *)(tl()->pointer_to(fnc - 1))); } inline int XPlex::Pix_to_index(Pix px) const { * p = (*)px; if (!ch->actual_pointer(p)) cache(p); return ch->index_of(p); } inline Pix XPlex::index_to_Pix(int idx) const { if (!ch->actual_index(idx)) cache(idx); return (Pix)(ch->pointer_to(idx)); } inline Pix XPlex::first() const { return Pix(hd->IChunk::first_pointer()); } inline Pix XPlex::last() const { return Pix(tl()->IChunk::last_pointer()); } inline void XPlex::prev(Pix& p) const { Pix q = Pix(ch->IChunk::pred((*) p)); p = (q == 0)? Pix(dopred((const *) p)) : q; } inline void XPlex::next(Pix& p) const { Pix q = Pix(ch->IChunk::succ((*) p)); p = (q == 0)? Pix(dosucc((const *)p)) : q; } inline & XPlex:: operator () (Pix p) { return *((*)p); } inline const & XPlex:: operator () (Pix p) const { return *((const *)p); } inline void XPlex::set_cache(const IChunk* t) const { ((XPlex*)(this))->ch = (IChunk*)t; } #endif #endif