UCommon
vector.h
Go to the documentation of this file.
1 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
2 //
3 // This file is part of GNU uCommon C++.
4 //
5 // GNU uCommon C++ is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published
7 // by the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // GNU uCommon C++ is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public License
16 // along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
17 
27 #ifndef _UCOMMON_VECTOR_H_
28 #define _UCOMMON_VECTOR_H_
29 
30 #ifndef _UCOMMON_THREAD_H_
31 #include <ucommon/thread.h>
32 #endif
33 
34 typedef unsigned short vectorsize_t;
35 
36 NAMESPACE_UCOMMON
37 
45 class __EXPORT ArrayReuse : public ReusableAllocator
46 {
47 private:
48  size_t objsize;
49  unsigned count, limit, used;
50  caddr_t mem;
51 
52 protected:
53  ArrayReuse(size_t objsize, unsigned c);
54  ArrayReuse(size_t objsize, unsigned c, void *memory);
55 
56 public:
60  ~ArrayReuse();
61 
62 protected:
63  bool avail(void);
64 
65  ReusableObject *get(timeout_t timeout);
66  ReusableObject *get(void);
67  ReusableObject *request(void);
68 };
69 
77 class __EXPORT PagerReuse : protected MemoryRedirect, protected ReusableAllocator
78 {
79 private:
80  unsigned limit, count;
81  size_t osize;
82 
83 protected:
84  PagerReuse(mempager *pager, size_t objsize, unsigned count);
85  ~PagerReuse();
86 
87  bool avail(void);
88  ReusableObject *get(void);
89  ReusableObject *get(timeout_t timeout);
90  ReusableObject *request(void);
91 };
92 
108 class __EXPORT Vector
109 {
110 public:
111  class __EXPORT array : public CountedObject
112  {
113  public:
114 #pragma pack(1)
115  vectorsize_t max, len;
116  ObjectProtocol *list[1];
117 #pragma pack()
118 
119  array(vectorsize_t size);
120  void dealloc(void);
121  void set(ObjectProtocol **items);
122  void add(ObjectProtocol **list);
123  void add(ObjectProtocol *obj);
124  void purge(void);
125  void inc(vectorsize_t adj);
126  void dec(vectorsize_t adj);
127  };
128 
129 protected:
130  array *data;
131 
132  array *create(vectorsize_t size) const;
133 
134  virtual void release(void);
135  virtual void cow(vectorsize_t adj = 0);
136  ObjectProtocol **list(void) const;
137 
138  friend class Vector::array;
139 
140 protected:
145  virtual ObjectProtocol *invalid(void) const;
146 
147 public:
151  static const vectorsize_t npos;
152 
156  Vector();
157 
162  Vector(vectorsize_t size);
163 
173  Vector(ObjectProtocol **items, vectorsize_t size = 0);
174 
178  virtual ~Vector();
179 
184  vectorsize_t len(void) const;
185 
191  vectorsize_t size(void) const;
192 
198  ObjectProtocol *get(int index) const;
199 
206  vectorsize_t get(void **mem, vectorsize_t max) const;
207 
213  ObjectProtocol *begin(void) const;
214 
220  ObjectProtocol *end(void) const;
221 
228  vectorsize_t find(ObjectProtocol *pointer, vectorsize_t offset = 0) const;
229 
235  void split(vectorsize_t position);
236 
243  void rsplit(vectorsize_t position);
244 
251  void set(vectorsize_t position, ObjectProtocol *pointer);
252 
257  void set(ObjectProtocol **list);
258 
263  void add(ObjectProtocol **list);
264 
269  void add(ObjectProtocol *pointer);
270 
274  void clear(void);
275 
280  virtual bool resize(vectorsize_t size);
281 
286  inline void set(Vector &vector)
287  {set(vector.list());};
288 
293  inline void add(Vector &vector)
294  {add(vector.list());};
295 
300  inline ObjectProtocol *operator[](int index)
301  {return get(index);};
302 
308  inline void operator()(vectorsize_t position, ObjectProtocol *pointer)
309  {set(position, pointer);};
310 
316  inline ObjectProtocol *operator()(vectorsize_t position)
317  {return get(position);};
318 
324  {add(pointer);};
325 
330  inline void operator=(Vector &vector)
331  {set(vector.list());};
332 
337  inline void operator+=(Vector &vector)
338  {add(vector.list());};
339 
344  inline Vector& operator+(Vector &vector)
345  {add(vector.list()); return *this;};
346 
351  Vector &operator^(Vector &vector);
352 
359  void operator^=(Vector &vector);
360 
364  void operator++();
365 
369  void operator--();
370 
375  void operator+=(vectorsize_t count);
376 
381  void operator-=(vectorsize_t count);
382 
388  static vectorsize_t size(void **list);
389 };
390 
396 class __EXPORT MemVector : public Vector
397 {
398 private:
399  bool resize(vectorsize_t size);
400  void cow(vectorsize_t adj = 0);
401  void release(void);
402 
403  friend class Vector::array;
404 
405 public:
411  MemVector(void *pointer, vectorsize_t size);
412 
416  ~MemVector();
417 
422  inline void operator=(Vector &vector)
423  {set(vector);};
424 
425 };
426 
432 template<class T>
433 class vectorof : public Vector
434 {
435 public:
439  inline vectorof() : Vector() {};
440 
445  inline vectorof(vectorsize_t size) : Vector(size) {};
446 
447  inline T& operator[](int index)
448  {return static_cast<T&>(Vector::get(index));};
449 
450  inline const T& at(int index)
451  {return static_cast<const T&>(Vector::get(index));};
452 
458  inline T *operator()(vectorsize_t position)
459  {return static_cast<T *>(Vector::get(position));};
460 
465  inline T *begin(void)
466  {return static_cast<T *>(Vector::begin());};
467 
472  inline T *end(void)
473  {return static_cast<T *>(Vector::end());};
474 
480  inline Vector &operator+(Vector &vector)
481  {Vector::add(vector); return static_cast<Vector &>(*this);};
482 };
483 
490 template<class T>
491 class array_reuse : protected ArrayReuse
492 {
493 public:
498  inline array_reuse(unsigned count) :
499  ArrayReuse(sizeof(T), count) {};
500 
506  inline array_reuse(unsigned count, void *memory) :
507  ArrayReuse(sizeof(T), count, memory) {};
508 
513  inline operator bool() const
514  {return avail();};
515 
520  inline bool operator!() const
521  {return !avail();};
522 
527  inline T* request(void)
528  {return static_cast<T*>(ArrayReuse::request());};
529 
535  inline T* get(void)
536  {return static_cast<T*>(ArrayReuse::get());};
537 
543  inline T* create(void)
544  {return init<T>(static_cast<T*>(ArrayReuse::get()));};
545 
552  inline T* get(timeout_t timeout)
553  {return static_cast<T*>(ArrayReuse::get(timeout));};
554 
561  inline T* create(timeout_t timeout)
562  {return init<T>(static_cast<T*>(ArrayReuse::get(timeout)));};
563 
568  inline void release(T *object)
569  {ArrayReuse::release(object);};
570 
576  inline operator T*()
577  {return array_reuse::get();};
578 
584  inline T *operator*()
585  {return array_reuse::get();};
586 };
587 
594 template <class T>
595 class paged_reuse : protected PagerReuse
596 {
597 public:
605  inline paged_reuse(mempager *pager, unsigned count) :
606  PagerReuse(pager, sizeof(T), count) {};
607 
612  inline operator bool() const
613  {return PagerReuse::avail();};
614 
619  inline bool operator!() const
620  {return !PagerReuse::avail();};
621 
627  inline T *get(void)
628  {return static_cast<T*>(PagerReuse::get());};
629 
636  inline T *create(void)
637  {return init<T>(static_cast<T*>(PagerReuse::get()));};
638 
645  inline T *get(timeout_t timeout)
646  {return static_cast<T*>(PagerReuse::get(timeout));};
647 
655  inline T *create(timeout_t timeout)
656  {return init<T>(static_cast<T*>(PagerReuse::get(timeout)));};
657 
662  inline T *request(void)
663  {return static_cast<T*>(PagerReuse::request());};
664 
669  inline void release(T *object)
670  {PagerReuse::release(object);};
671 
677  inline T *operator*()
678  {return paged_reuse::get();};
679 
685  inline operator T*()
686  {return paged_reuse::get();};
687 };
688 
696 template<typename T, vectorsize_t S>
697 class vectorbuf : public MemVector
698 {
699 private:
700  char buffer[sizeof(array) + (S * sizeof(void *))];
701 
702 public:
706  inline vectorbuf() : MemVector(buffer, S) {};
707 
713  inline const T& at(int index)
714  {return static_cast<const T&>(Vector::get(index));};
715 
716  inline T& operator[](int index)
717  {return static_cast<T&>(Vector::get(index));};
718 
724  inline T *operator()(vectorsize_t position)
725  {return static_cast<T *>(Vector::get(position));};
726 
731  inline T *begin(void)
732  {return static_cast<T *>(Vector::begin());};
733 
738  inline T *end(void)
739  {return static_cast<T *>(Vector::end());};
740 
746  inline Vector &operator+(Vector &vector)
747  {Vector::add(vector); return static_cast<Vector &>(*this);};
748 };
749 
750 END_NAMESPACE
751 
752 #endif