1#ifndef _RHEO_SMART_POINTER_H
2#define _RHEO_SMART_POINTER_H
123#include "rheolef/compiler.h"
130template <
class T,
class C>
165#pragma GCC diagnostic push
166#pragma GCC diagnostic ignored "-Weffc++"
169#pragma GCC diagnostic pop
171 counter (
const counter&);
172 counter& operator= (
const counter&);
184template <
class T,
class C>
186smart_pointer_base<T,C>::counter::counter (
T*
p)
190template <
class T,
class C>
192smart_pointer_base<T,C>::counter::~counter ()
196#pragma GCC diagnostic push
197#pragma GCC diagnostic ignored "-Weffc++"
198template <
class T,
class C>
201smart_pointer_base<T,C>::counter::operator++ ()
205template <
class T,
class C>
208smart_pointer_base<T,C>::counter::operator-- ()
210 if (--_n != 0)
return _n;
214#pragma GCC diagnostic pop
218template <
class T,
class C>
221: _count(new_macro(counter(
p)))
224template <
class T,
class C>
227: _count(static_cast<counter*>(count))
231template <
class T,
class C>
238template <
class T,
class C>
242 if (_count != 0) { --(*_count); }
244template <
class T,
class C>
249 if (_count != sp._count) {
256template <
class T,
class C>
263template <
class T,
class C>
270template <
class T,
class C>
277template <
class T,
class C>
284template <
class T,
class C>
290 if (_count -> _p == 0)
return 0;
291 if (_count -> _n > 1) {
293 T* q = C()(*(_count -> _p));
294 _count = new_macro (counter(q));
298template <
class T,
class C>
305template <
class T,
class C>
312template <
class T,
class C>
326struct constructor_copy {
327 T* operator() (
const T& data)
throw() {
return new_macro(
T(data)); }
333 T* operator() (
const T& from)
throw() {
return from.clone(); }
339 T* operator() (
const T& from) {
340 error_macro (
"no_copy functor called (illegal copy)");
352 typedef details::constructor_copy<T> C;
361 base::operator= (x);
return *
this; }
371 typedef details::clone_copy<T> C;
380 base::operator= (x);
return *
this; }
390 typedef details::no_copy<T> C;
399 base::operator= (x);
return *
this; }
406#ifdef _RHEO_SMART_POINTER_TST_CC
416class container_data {
426 container_data (
const container_data& x)
427 : values(new
T[x.
n]),
n(x.
n)
428 {
for (
int i=0; i<
n;i++) values[i]=x.values[i];}
429 container_data& operator= (
const container_data& x) {
432 for (
int i=0; i<
n;i++) values[i]=x.values[i];
436 explicit container_data(
int n1)
437 : values(new
T[n1]),
n(n1) {}
439 ~container_data() {
delete [] values; }
442 const T& operator[](
int i)
const
443 {
return values[i]; }
445 {
return values[i]; }
453 explicit container(
int n = 0);
456 const T& operator[](
int i)
const;
457 T& operator[](
int i);
462container::container (
int n)
466container::operator[] (
int i)
const {
468 return data().operator[] (i);
471container::operator[] (
int i) {
473 return data().operator [] (i);
482 std::cerr <<
"fatal: It is not a true copy semantic." << std::endl;
485 std::cerr <<
"It seems to be a true copy semantic." << std::endl;
smart_pointer_base(T *p=0)
smart_pointer_base(void *count, internal)
const T & operator*() const
const T * pointer() const
counter * get_count() const
smart_pointer_base(const smart_pointer_base< T, C > &)
int reference_counter() const
const T * operator->() const
smart_pointer_base< T, C > & operator=(const smart_pointer_base< T, C > &)
smart_pointer_clone(T *p=0)
smart_pointer_clone(const smart_pointer_clone< T > &x)
smart_pointer_clone< T > & operator=(const smart_pointer_clone< T > &x)
smart_pointer_clone(void *count, internal i)
smart_pointer_nocopy(const smart_pointer_nocopy< T > &x)
smart_pointer_nocopy< T > & operator=(const smart_pointer_nocopy< T > &x)
smart_pointer_nocopy(T *p=0)
smart_pointer_nocopy(void *count, internal i)
see the smart_pointer page for the full documentation
smart_pointer(void *count, internal i)
smart_pointer< T > & operator=(const smart_pointer< T > &x)
smart_pointer(const smart_pointer< T > &x)
#define error_macro(message)
This file is part of Rheolef.