// 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 _RPlex_h #ifdef __GNUG__ #pragma once #pragma interface #endif #define _RPlex_h 1 #include ".Plex.h" // minimum number of chunks to index #ifndef MIN_NCHUNKS #define MIN_NCHUNKS 16 #endif class RPlex: public Plex { int base; // base index of lowest chunk int lch; // index of lowest used chunk int fch; // 1 + index of highest used chunk int maxch; // max chunks in array IChunk** chunks; // array of chunks 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: RPlex(); // set low = 0; // fence = 0; // csize = default RPlex(int ch_size); // low = 0; // fence = 0; // csize = ch_size RPlex(int lo, // low = lo; int ch_size); // fence=lo // csize = ch_size RPlex(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 RPlex(const RPlex&); ~RPlex(); void operator= (const RPlex&); // 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 RPlex& a); void prepend(const RPlex& a); int reset_low(int newlow); int OK () const; }; #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES) inline void RPlex::prev(int& idx) const { --idx; } inline void RPlex::next(int& idx) const { ++idx; } inline int RPlex::full () const { return 0; } inline int RPlex::can_add_high() const { return 1; } inline int RPlex::can_add_low() const { return 1; } inline int RPlex::valid (int idx) const { return idx >= lo && idx < fnc; } inline int RPlex::low() const { return lo; } inline int RPlex::high() const { return fnc - 1; } inline void RPlex::set_cache(const IChunk* t) const { ((RPlex*)(this))->ch = (IChunk*)t; } inline void RPlex::cache(int idx) const { if (idx < lo || idx >= fnc) index_error(); set_cache(chunks[(idx - base) / csize]); } inline & RPlex::low_element () { cache(lo); return *(ch->pointer_to(lo)); } inline & RPlex::high_element () { cache(fnc-1); return *(ch->pointer_to(fnc - 1)); } inline const & RPlex::low_element () const { cache(lo); return *((const *)(ch->pointer_to(lo))); } inline const & RPlex::high_element () const { cache(fnc-1); return *((const *)(ch->pointer_to(fnc - 1))); } inline int RPlex::Pix_to_index(Pix px) const { * p = (*)px; if (!ch->actual_pointer(p)) cache(p); return ch->index_of(p); } inline Pix RPlex::index_to_Pix(int idx) const { if (!ch->actual_index(idx)) cache(idx); return (Pix)(ch->pointer_to(idx)); } inline Pix RPlex::first() const { return Pix(hd->IChunk::first_pointer()); } inline Pix RPlex::last() const { return Pix(tl()->IChunk::last_pointer()); } inline void RPlex::prev(Pix& p) const { Pix q = Pix(ch->IChunk::pred((*)p)); p = (q == 0)? Pix(dopred((*)p)) : q; } inline void RPlex::next(Pix& p) const { Pix q = Pix(ch->IChunk::succ((*)p)); p = (q == 0)? Pix(dosucc((*)p)) : q; } inline & RPlex:: operator () (Pix p) { return *((*)p); } inline & RPlex:: operator [] (int idx) { cache(idx); return *(ch->pointer_to(idx)); } inline const & RPlex:: operator () (Pix p) const { return *((const *)p); } inline const & RPlex:: operator [] (int idx) const { cache(idx); return *((const *)(ch->pointer_to(idx))); } inline RPlex::~RPlex() { delete chunks; } #endif #endif