newlib-cygwin/winsup/cygwin/vstrlist.h

374 lines
8.8 KiB
C++

/* vstrlist.h: class vstrlist
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#ifdef __cplusplus
struct allocator_interface
{
virtual void * alloc (size_t) = 0;
virtual void free (void *) = 0;
};
/* The allocated_type makes sure to use the free () method of the
same allocator_interface than the alloc () method was used of.
Stores the allocator_interface address before the real object,
to hide it from (construction & destruction of) real object. */
class allocated_type
{
union allocator_store
{
allocator_interface * allocator_;
char alignment_[8];
union pointer
{
void * vptr;
allocator_store * real;
};
};
public:
void * operator new (size_t class_size, allocator_interface & allocator)
{
allocator_store::pointer astore;
astore.vptr = allocator.alloc (sizeof (allocator_store) + class_size);
astore.real->allocator_ = &allocator;
++ astore.real;
return astore.vptr;
}
void operator delete (void * p)
{
allocator_store::pointer astore;
astore.vptr = p;
-- astore.real;
astore.real->allocator_->free (astore.vptr);
}
};
/* Double linked list of char arrays, each being a string buffer,
which's final buffer size and initial string content is defined
by a NULL terminated variable argument list of STRING+LEN pairs,
where each STRING (up to LEN) is concatenated for the initial
string buffer content, and each LEN is added to the final size
of the allocated string buffer.
If LEN is -1, strlen(STRING) is used for LEN.
Needs:
An implementation of the allocator_interface.
Provides:
iterator:
short name for the string_iterator
string_iterator:
provides readonly access via member methods:
string (): readonly string buffer
stringlength (): length (readonly) of initial string
buffer_iterator:
extends string_iterator
provides writeable access via member methods:
buffer (): writeable string buffer
bufferlength (): length (readonly) of allocated buffer
Usage sample:
char * text = "snipe";
vstrlist l;
l.appendv (text, 4, text+3, 2, "", 2, NULL);
buffer_iterator it (l.begin ());
strcpy (it->buffer () + it->stringlength (), "ts");
printf ("Sample result is: '%s'", it->string ());
Sample result is: 'snippets' */
class vstrlist
{
public:
class member
: public allocated_type
{
friend class vstrlist;
friend class string_iterator;
member * prev_;
member * next_;
size_t bufferlength_;
size_t stringlength_;
char buffer_[1]; /* we always have space for the trailing zero */
/* no copy, just swap */
member (member const &);
member & operator = (member const &);
/* anchor */
void * operator new (size_t class_size, allocator_interface & allocator)
{
return allocated_type::operator new (class_size, allocator);
}
/* anchor */
member ()
: allocated_type ()
, prev_ (this)
, next_ (this)
, bufferlength_ (0)
, stringlength_ (0)
, buffer_ ()
{}
/* entry: determine memory size from args */
void * operator new (size_t class_size, allocator_interface & allocator,
char const * part0, va_list parts)
{
char const * part = part0;
va_list partsdup;
va_copy (partsdup, parts);
while (part)
{
int partlen = va_arg (partsdup, int);
if (partlen < 0)
partlen = strlen (part);
class_size += partlen;
part = va_arg (partsdup, char const *);
}
va_end (partsdup);
return allocated_type::operator new (class_size, allocator);
}
/* entry: instantly insert into list */
member (member * before, char const * part0, va_list parts)
: allocated_type ()
, prev_ (NULL)
, next_ (NULL)
, bufferlength_ (0)
, stringlength_ ()
, buffer_ ()
{
prev_ = before->prev_;
next_ = before;
prev_->next_ = this;
next_->prev_ = this;
char * dest = buffer_;
char const * part = part0;
va_list partsdup;
va_copy (partsdup, parts);
while (part)
{
int partlen = va_arg (partsdup, int);
if (partlen < 0)
{
char * old = dest;
dest = stpcpy (old, part);
partlen = dest - old;
}
else
dest = stpncpy (dest, part, partlen);
bufferlength_ += partlen;
part = va_arg (partsdup, const char *);
}
va_end (partsdup);
*dest = (char)0;
stringlength_ = dest - buffer_;
if (bufferlength_ > stringlength_)
memset (++dest, 0, bufferlength_ - stringlength_);
}
/* remove entry from list */
~member ()
{
member * next = next_;
member * prev = prev_;
if (next)
next->prev_ = prev;
if (prev)
prev->next_ = next;
prev_ = NULL;
next_ = NULL;
}
public:
member const * next () const { return next_; }
member * next () { return next_; }
member const * prev () const { return next_; }
member * prev () { return next_; }
/* readonly access */
char const * string () const { return buffer_; }
size_t stringlength () const { return stringlength_; }
/* writeable access */
char * buffer () { return buffer_; }
size_t bufferlength () { return bufferlength_; }
};
/* readonly access */
class string_iterator
{
friend class vstrlist;
friend class buffer_iterator;
member * current_;
string_iterator ();
string_iterator (member * current)
: current_ (current)
{}
public:
string_iterator (string_iterator const & rhs)
: current_ (rhs.current_)
{}
string_iterator & operator = (string_iterator const & rhs)
{
current_ = rhs.current_;
return *this;
}
string_iterator & operator ++ ()
{
current_ = current_->next ();
return *this;
}
string_iterator operator ++ (int)
{
string_iterator ret (*this);
current_ = current_->next ();
return ret;
}
string_iterator & operator -- ()
{
current_ = current_->prev ();
return *this;
}
string_iterator operator -- (int)
{
string_iterator ret (*this);
current_ = current_->prev ();
return ret;
}
bool operator == (string_iterator const & rhs) const
{
return current_ == rhs.current_;
}
bool operator != (string_iterator const & rhs) const
{
return current_ != rhs.current_;
}
/* readonly member access */
member const & operator * () const { return *current_; }
member const * operator -> () const { return current_; }
void remove ()
{
member * old = current_;
++ *this;
delete old;
}
};
/* writeable access */
class buffer_iterator
: public string_iterator
{
public:
explicit /* can be used with vstrlist.begin () */
buffer_iterator (string_iterator const & begin)
: string_iterator (begin)
{}
buffer_iterator (buffer_iterator const & rhs)
: string_iterator (rhs)
{}
buffer_iterator & operator = (buffer_iterator const & rhs)
{
string_iterator::operator = (rhs);
return *this;
}
/* writeable member access */
member & operator * () const { return *current_; }
member * operator -> () const { return current_; }
};
private:
allocator_interface & allocator_;
member * anchor_;
/* not without an allocator */
vstrlist ();
/* no copy, just swap () */
vstrlist (vstrlist const &);
vstrlist & operator = (vstrlist const &);
public:
/* iterator is the string_iterator */
typedef class string_iterator iterator;
iterator begin () { return iterator (anchor_->next ()); }
iterator end () { return iterator (anchor_ ); }
iterator rbegin () { return iterator (anchor_->prev ()); }
iterator rend () { return iterator (anchor_ ); }
vstrlist (allocator_interface & a)
: allocator_ (a)
, anchor_ (NULL) /* exception safety */
{
anchor_ = new (allocator_) member ();
}
~vstrlist ()
{
if (anchor_ != NULL)
{
for (iterator it = begin (); it != end (); it.remove ());
delete anchor_;
}
}
void swap (vstrlist & that)
{
allocator_interface & a = allocator_;
member * m = anchor_;
allocator_ = that.allocator_;
anchor_ = that.anchor_;
that.allocator_ = a;
that.anchor_ = m;
}
string_iterator appendv (char const * part0, va_list parts)
{
member * ret = new (allocator_, part0, parts)
member (anchor_, part0, parts);
return string_iterator (ret);
}
string_iterator appendv (char const * part0, ...)
{
va_list parts;
va_start (parts, part0);
string_iterator ret = appendv (part0, parts);
va_end (parts);
return ret;
}
};
#endif /* __cplusplus */