Subversion Repositories openrisc_me

// { dg-do assemble  }

// prms-id: 13911

template

class ref_counter {

public:

  ref_counter() : p_refcnt(new unsigned int(N)) {}

  ref_counter(const ref_counter& x) : p_refcnt(x.p_refcnt) {

    ++*p_refcnt;

  }

  ref_counter& operator=(const ref_counter& 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 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& 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& lhs,

                         const ref_pointer& rhs) {

    return lhs.the_p == rhs.the_p;

  }

  friend bool operator!=(const ref_pointer& lhs,

                         const ref_pointer& 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& refCount() {return ref_count;}

private:

  ref_counter ref_count;

  T* the_p;

};

template

ref_pointer& ref_pointer::operator=(const ref_pointer& 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

ref_pointer& ref_pointer::operator=(T* just_newed) {

  if (unique()) delete the_p;

  the_p = just_newed;

  ref_count = ref_counter();

  return *this;

}

template

class CountedObjPtr : public ref_pointer {

public:

  CountedObjPtr() {}

  CountedObjPtr(T* just_newed) : ref_pointer(just_newed) {}

  CountedObjPtr(T* the_p_arg, ref_counter<1>& ref_count_arg)

    : ref_pointer(the_p_arg, ref_count_arg) {}

  CountedObjPtr& operator=(T* rhs) {

    ref_pointer::operator=(rhs);

    return *this;

  }

  CountedObjPtr& operator=(const CountedObjPtr& rhs) {

    ref_pointer::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;