/home/rex/ebltrunk/core/libidx/include/smart.h

/***************************************************************************
 *   Copyright (C) 2011 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef SMART_H
#define SMART_H

#include <stdio.h>
#include "defines.h"
#include "stl.h"

namespace ebl {

  // smart_pointer /////////////////////////////////////////////////////////////

  class EXPORT smart_pointer {
  public:
    // basic constructors/destructor ///////////////////////////////////////////

    smart_pointer();
    smart_pointer(const smart_pointer &other);
    virtual ~smart_pointer();

    // reference counting //////////////////////////////////////////////////////

    virtual int unlock();
    virtual int lock();
    virtual int get_count();

    virtual void set_count(int count);

    // friends /////////////////////////////////////////////////////////////////
    template <class T> friend class svector;

    // members variables ///////////////////////////////////////////////////////
  protected:
    int refcount; 

    // debug only //////////////////////////////////////////////////////////////
#ifdef __DEBUGMEM__
  public:
    static intg locks; 
    static intg spointers; 
#endif
    //#ifdef __DEBUG__
    std::string debug_name;
    //#endif
  };

  // svector ///////////////////////////////////////////////////////////////////

  template <class T>
    class EXPORT svector : public std::vector<T*>, public smart_pointer {
  public:
    svector();
    svector(const svector<T> &other);
    svector(uint n);
    virtual ~svector();

    virtual void clear();
    virtual void clear(uint i);

    virtual T& operator[](uint i);
    /* //! Returns a reference to T at index 'i'. */
    /* virtual const T& operator[](uint i) const; */
    virtual const T& at_const(uint i) const;

    virtual bool exists(uint i) const;
    virtual uint size_existing() const;

    virtual void remove(uint i);
    virtual void remove(uint start, uint end);
    virtual void remove_empty();

    virtual void push_front(T &e);
    virtual void push_front_new(T &e);

    virtual void push_back(T *e);
    virtual void push_back(T &e);
    virtual void push_back_new(const T &e);
    virtual void push_back_new(const T *e);
    virtual void push_back(std::vector<T*> &v);
    virtual void push_back(svector<T> &v);
    virtual void push_back_new(const svector<T> &v);
    virtual void push_back_empty();

    virtual void set(T& e, uint n);
    virtual void set_new(T& e, uint n);

    /* //! Clear all elements, then lock and push all elements of 'v' to the end. */
    /* virtual svector<T>& operator=(svector<T> &v); */
    virtual void operator=(svector<T> v);

    virtual void swap(uint i, uint j);

    virtual svector<T> copy();
    virtual void copy(const svector<T> &other);
    virtual void copy(svector<T> &other);
    virtual svector<T> narrow(uint n, uint offset);
    virtual void resize_default(uint n);

    virtual void randomize();

    // iterators ///////////////////////////////////////////////////////////////

    class iterator;
    class const_iterator;
    virtual iterator begin(uint offset = 0);
    virtual const_iterator begin(uint offset = 0) const;

    // TEMPORARLY OUT
    void lock_all();
    // internal methods ////////////////////////////////////////////////////////
  protected:
    void unlock_all();
    void unlock_range(uint start, uint end);

    // members /////////////////////////////////////////////////////////////////
  protected:
    typename std::vector<T*>::iterator it;
  };

  // iterator //////////////////////////////////////////////////////////////////

  template <class T>
    class svector<T>::iterator : public std::vector<T*>::iterator {
  public:
    iterator();
    iterator(typename std::vector<T*>::iterator &i);
    iterator(typename std::vector<T*>::iterator i);
    virtual ~iterator();

    inline virtual T& operator*();
    inline virtual T* operator->();
    inline virtual T* ptr();
    inline virtual bool exists() const;
  };

  // const_iterator ////////////////////////////////////////////////////////////

  template <class T>
    class svector<T>::const_iterator : public std::vector<T*>::const_iterator {
  public:
    const_iterator();
    const_iterator(typename std::vector<T*>::const_iterator &i);
    const_iterator(typename std::vector<T*>::const_iterator i);
    virtual ~const_iterator();

    inline virtual const T& operator*() const;
    inline virtual const T* operator->() const;
    inline virtual const T* ptr() const;
    inline virtual bool exists() const;
  };

  // printing //////////////////////////////////////////////////////////////////

  template <class T, class stream>
    EXPORT stream& operator<<(stream &o, const svector<T> &v);
  template <class T, class stream>
    EXPORT stream& operator<<(stream &o, svector<T> &v);

} // end namespace ebl

#include "smart.hpp"

#endif /* SMART_H_ */