home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

reference_count.h

Go to the documentation of this file.

/*
 * Copyright © 2000, 2001 Sofus Mortensen, Paul Hollingsworth
 *
 * This material is provided "as is", with absolutely no warranty 
 * expressed or implied. Any use is at your own risk. Permission to 
 * use or copy this software for any purpose is hereby granted without 
 * fee, provided the above notices are retained on all copies. 
 * Permission to modify the code and to distribute modified code is 
 * granted, provided the above notices are retained, and a notice that 
 * the code was modified is included with the above copyright notice. 
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#ifndef COMET_REFERENCE_COUNT_H
#define COMET_REFERENCE_COUNT_H

#include <comet/config.h>
#include <algorithm>

namespace comet {

        class reference_count 
        {
        public:
                reference_count() : rc_(0) {};
                explicit reference_count(size_t x) : rc_(reinterpret_cast<size_t*>(x)) {};
                
                reference_count(const reference_count& x) : rc_(x.rc_) {};
                
                enum { FLAGVALUE = 1 };
                bool is_flag() const { 
                        return reinterpret_cast<size_t>(rc_) == 1;
                }

                // is_null
                bool is_null() const {
                        return rc_ == 0;
                }
                
                size_t operator++() { 
                        if (!rc_) {
                                rc_ = new size_t(1);
                        }
                        return ++*rc_; 
                }
                
                size_t operator--() { 
                        if (rc_) {
                                if (--*rc_ == 0) { 
                                        delete rc_;
                                        rc_ = 0;
                                        return 0;
                                }
                                return *rc_;
                        }
                        return 0;
                }
                
                void clear() {
                        rc_ = 0;
                }

                void swap(reference_count &rhs) throw() {
                        std::swap(rc_, rhs.rc_);
                }

                reference_count& operator=(reference_count& x)
                {
                        rc_ = x.rc_;
                        return *this;
                }
                
        private:
                size_t* rc_;
        }; // class reference_count
} // namespace comet

namespace std {
        template<> inline void swap(comet::reference_count &lhs, comet::reference_count &rhs) COMET_STD_SWAP_NOTHROW
        {
                lhs.swap(rhs);
        }
}

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.