smart.h

Go to the documentation of this file.

#ifndef __SMART_H
#define __SMART_H

/* Copyright (C) 2017 - James Terman
 *
 * milo is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * milo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <vector>
#include <memory>
#include <initializer_list>

template <class T>
class SmartPtr : public std::shared_ptr<T>
{
public:
    explicit SmartPtr() : std::shared_ptr<T>() {}

    explicit SmartPtr(T* p) : std::shared_ptr<T>(p) {}

    explicit SmartPtr(const std::shared_ptr<T>& sp) : std::shared_ptr<T>(sp) {}
    
    SmartPtr& operator=(T* p) { SmartPtr a(p->getSharedPtr()); *this = a; return *this; }

    bool operator==(T* p) const { return this->get() == p; }

    bool operator!=(T* p) const { return this->get() != p; }

    operator T*() const { return this->get(); }
};

template <class T>
class SmartVector : public std::vector< SmartPtr<T> >
{
public:
    using iterator = typename std::vector< SmartPtr<T> >::iterator;
    using const_iterator = typename std::vector< SmartPtr<T> >::const_iterator;
    using size_type = typename std::vector< std::shared_ptr<T> >::size_type;
    using base = typename std::vector< SmartPtr<T> >;

    SmartVector() {}

    explicit SmartVector(std::initializer_list<T*> li)
    {
        for ( T* n : li ) { this->push_back(n); }
    }
        
    explicit SmartVector(T* p) { SmartPtr<T> a; a = p; this->base::push_back(a); } 

    SmartVector(std::initializer_list< SmartPtr<T> > li) : base(li) {}

    void push_back(T* p) { SmartPtr<T> a; a = p; this->base::push_back(a);  }

    void push_back(const SmartPtr<T>&) = delete;

    void push_back(const SmartPtr<T>&&) = delete;

    iterator insert(const_iterator pos, T* val)
    {
        return this->base::insert(pos, SmartPtr<T>(val));
    }
    
    iterator insert(const_iterator pos, size_type n, const T* val)
    {
        return this->base::insert(pos, n, SmartPtr<T>(val));
    }

    iterator insert (const_iterator position, iterator first, iterator last)
    {
        return this->base::insert(position, first, last);
    }

    iterator insert(const_iterator pos, const SmartPtr<T> val)
    {
        return this->base::insert(pos, val);
    }

    iterator insert(const_iterator pos, size_type n, const  SmartPtr<T> val) = delete;

    iterator insert(const_iterator pos, std::initializer_list< SmartPtr<T> > il) = delete;

    void swap(SmartVector<T>& v) { this->base::swap(v); }

    void swap(base&) = delete;

    void merge(SmartVector<T>& v, iterator pos)
    {
        this->base::reserve(this->base::size() + v.size());
        insert(pos, v.base::begin(), v.base::end());
        v.base::clear();
    }

    void merge(SmartVector<T>& v) { this->merge(v, this->base::begin()); }
    void insert_index(int index, T* e)
    {
        insert((index < 0 ? base::end() : base::begin()) + index, e);
    }

    void erase_index(int index)
    {
        this->erase((index < 0 ? base::end() - 1 : base::begin()) + index);
    }

    int get_index(T* e) const
    {
        const base* base_this = this;
        int index = 0;
        for ( auto n : *base_this ) {
            if (n.get() == e) return index;
            ++index;
        }
        return -1;
    }

    iterator find(T* e) { return this->base::begin() + get_index(e); }
};

template<class T>
bool operator==(const SmartPtr<T>& p, const typename SmartVector<T>::iterator& it)
{
    return p.get() == it->get();
}

template<class T>
bool operator!=(const SmartPtr<T>& p, const typename SmartVector<T>::iterator& it)
{
    return p.get() != it->get();
}

template<class T>
bool operator==(const typename SmartVector<T>::iterator& it, const SmartPtr<T>& p)
{
    return p.get() == it->get();
}

template<class T>
bool operator!=(const typename SmartVector<T>::iterator& it, const SmartPtr<T>& p)
{
    return p.get() != it->get();
}

#endif // __SMART_H