URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [gcc/] [testsuite/] [g++.old-deja/] [g++.benjamin/] [tem01.C] - Rev 516
Compare with Previous | Blame | View Log
// { dg-do assemble }
// prms-id: 13911
template<unsigned int N>
class ref_counter {
public:
ref_counter() : p_refcnt(new unsigned int(N)) {}
ref_counter(const ref_counter<N>& x) : p_refcnt(x.p_refcnt) {
++*p_refcnt;
}
ref_counter& operator=(const ref_counter<N>& rhs) {
++*rhs.p_refcnt;
decrement();
p_refcnt = rhs.p_refcnt;
return *this;
}
~ref_counter() {decrement();}
bool unique() const {return *p_refcnt == N;}
private:
unsigned int* p_refcnt;
void decrement() {
if (unique()) delete p_refcnt;
else --*p_refcnt;
}
};
template<class T, unsigned int N>
class ref_pointer {
public:
ref_pointer() : the_p(0) {}
ref_pointer(T* just_newed) : the_p(just_newed) {}
virtual ~ref_pointer() {if (unique()) delete the_p;}
protected:
ref_pointer(T* the_p_arg, ref_counter<N>& ref_count_arg)
: the_p(the_p_arg), ref_count(ref_count_arg) {}
public:
ref_pointer& operator=(const ref_pointer&);
ref_pointer& operator=(T*);
operator const T*() const {return the_p;}
T* operator()() {return the_p;}
T* operator()() const {return the_p;}
T& operator*() const {return *the_p;}
friend bool operator==(const ref_pointer<T, N>& lhs,
const ref_pointer<T, N>& rhs) {
return lhs.the_p == rhs.the_p;
}
friend bool operator!=(const ref_pointer<T, N>& lhs,
const ref_pointer<T, N>& rhs) {
return lhs.the_p != rhs.the_p;
}
bool unique() const {return ref_count.unique();}
bool isNull() const {return the_p==0;}
protected:
ref_counter<N>& refCount() {return ref_count;}
private:
ref_counter<N> ref_count;
T* the_p;
};
template<class T, unsigned int N>
ref_pointer<T, N>& ref_pointer<T, N>::operator=(const ref_pointer<T, N>& rhs) {
if (the_p != rhs.the_p) {
if (unique()) delete the_p;
the_p = rhs.the_p;
ref_count = rhs.ref_count;
}
return *this;
}
template<class T, unsigned int N>
ref_pointer<T, N>& ref_pointer<T, N>::operator=(T* just_newed) {
if (unique()) delete the_p;
the_p = just_newed;
ref_count = ref_counter<N>();
return *this;
}
template<class T>
class CountedObjPtr : public ref_pointer<T, 1> {
public:
CountedObjPtr() {}
CountedObjPtr(T* just_newed) : ref_pointer<T, 1>(just_newed) {}
CountedObjPtr(T* the_p_arg, ref_counter<1>& ref_count_arg)
: ref_pointer<T, 1>(the_p_arg, ref_count_arg) {}
CountedObjPtr<T>& operator=(T* rhs) {
ref_pointer<T, 1>::operator=(rhs);
return *this;
}
CountedObjPtr<T>& operator=(const CountedObjPtr<T>& rhs) {
ref_pointer<T, 1>::operator=(rhs);
return *this;
}
T* operator->() const {return (*this)();}
};
//instantiating type
class TSObservable;
class TSObserver {
public:
enum TSType { NormalTS, UpYldCrvTS, DownYldCrvTS, ZeroVolTS };
virtual ~TSObserver() {}
virtual void update(TSObservable* theChangedObservable) = 0;
virtual TSType key() const { return myKey; }
virtual TSType& key() { return myKey; }
protected:
TSObserver(TSType myKeyArg) : myKey(myKeyArg) {}
TSType myKey;
};
//now try to instantiate
template class CountedObjPtr<TSObserver>;