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

auto_buffer.h

Go to the documentation of this file.

 /*
 * Copyright © 2004, Michael Geddes, Lijun Qin.
 *
 * 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 INCLUDE_COMET_AUTO_BUFFER_H
#define INCLUDE_COMET_AUTO_BUFFER_H

#ifdef _SHOW_INC
#pragma message("   #Include " __FILE__)
#endif

namespace comet
{

        template <typename T>
        class auto_buffer_t
        {
                public:
                        typedef size_t size_type;
                        explicit auto_buffer_t(size_type size)
                        {
                                begin_ = new T[size];
                        }
                        ~auto_buffer_t() throw() { delete[] begin_; }

                        void clear()  throw()
                        {
                                delete[] begin_;
                                begin_ =  0;
                        }
                        bool empty() const throw()
                        {
                                return begin_ != NULL;
                        }
                        void resize( size_type newSize) throw()
                        {
                                delete[] begin_;
                                begin_ =  new T[newSize];
                        }

                        T & at( size_type t) throw() { return begin_[t]; }
                        T & operator[]( size_type t) throw() { return begin_[t]; }
                        const T & at( size_type t) const throw() { return begin_[t]; }
                        const T & operator[]( size_type t) const throw() { return begin_[t]; }

                        T *detach()
                        {
                                T *val = begin_;
                                begin_ = NULL;
                                return val;
                        }
                        T *get() { return begin_; }
                        const T *get()const { return begin_; }

                private:
                        auto_buffer_t &operator=(const auto_buffer_t &);
                        auto_buffer_t(const auto_buffer_t&);

                        T *begin_;
        };
}

#endif /* INCLUDE_COMET_AUTO_BUFFER_H */

Copyright 2002 Sofus Mortensen. All rights reserved.