BaseHandler.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//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.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 MERCURYDPM DEVELOPERS TEAM 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 BASEHANDLER_H
#define BASEHANDLER_H

#include <iostream>
#include <vector>


template <class T>
class BaseHandler
{
public:
    BaseHandler()
    {
        clear();
        #ifdef CONSTUCTOR_OUTPUT
            std::cout << "BaseHandler::BaseHandler() finished" << std::endl;
        #endif
    }

    BaseHandler(const BaseHandler<T>& BH)
    {
        clear();
        for (typename std::vector<T*>::const_iterator it=BH.begin();it!=BH.end();it++)
        {
            addObject((*it)->copy());
        }
        #ifdef CONSTUCTOR_OUTPUT
            std::cout << "BaseHandler::BaseHandler(const BaseHandler &BH) finished" << std::endl;
        #endif
    }

 //   BaseHandler operator = (const BaseHandler<T>& rhs)
 //   {
 //       if (this != &rhs)
 //       {
 //           clear();
 //           for (typename std::vector<T*>::const_iterator it=rhs.begin();it!=rhs.end();it++)
 //           {
 //               addObject((*it)->copy());
 //           }
 //       }
 //       #ifdef OPERATOR_OUTPUT
 //           std::cout << "BaseHandler BaseHandler::operator = (const BoundaryHandler& rhs) finished" << std::endl;
 //       #endif
 //       return *this;
 //   }    

    virtual ~BaseHandler()
    {
        clear();
        #ifdef DESTRUCTOR_OUTPUT
            std::cout << "BaseHandler::~BaseHandler() finished" << std::endl;
        #endif
    }

    void copyAndAddObject(const T& O)
    {
        addObject(O.copy());
    }    

    void copyAndAddObject(const T* O)
    {
        addObject(O->copy());
    }       

    virtual void addObject(T* O)
    {
        objects_.push_back(O);
        //Set the index of the particle
        getLastObject()->set_Index(getNumberOfObjects()-1);
        //set the non changing particle identifier
        getLastObject()->set_Id(nextId_);
        //Update Id for next particle
        nextId_++;
        //Update the maximum number of Particles
        if(getNumberOfObjects()>maxObjects_) maxObjects_=getNumberOfObjects();              
    }

    virtual void removeObject(unsigned const int id)
    {
        if (id>=getNumberOfObjects())
        {
            std::cerr<<"In: void BaseHandler::removeObject(const unsigned int id) const"<<std::endl;
            std::cerr<<"No Object exist with index "<<id<<" number of objects is "<<getNumberOfObjects()<<std::endl;
            throw;          
        }
        
        //Physically remove Object
        delete objects_[id];

        //If the Object was the last Object nothing has to be done, otherwise some additional work is neccesary
        if (getObject(id) != getLastObject())
        {
            //Copy the pointer to the last Object to position id
            objects_[id] = getLastObject();
            objects_[id]->moveInHandler(id);
        }
        //Remove the (now double) reference to that last Object
        objects_.pop_back();
    }


    void removeLastObject()
    {
        if (getNumberOfObjects()==0)
        {
            std::cerr<<"In: void BaseHandler::removeLastObject const"<<std::endl;
            std::cerr<<"No Object exist in this BaseHandler"<<std::endl;
            throw;          
        }
        //Physically removes Object
        delete objects_.back();
        //Remove the (now double) reference to that last Object
        objects_.pop_back();        
    }

    void clear()
    {
        objects_.clear();
        nextId_=0;
        maxObjects_=0;        
    }

    virtual void readObject(std::istream& is)=0;

    T* getObject(const unsigned int id) const
    {
        if (id>=getNumberOfObjects())
        {
            std::cerr<<"In: Object* BaseHandler::getObject(const unsigned int id) const"<<std::endl;
            std::cerr<<"No Object exist with index "<<id<<" number of objects is "<<getNumberOfObjects()<<std::endl;
            throw;          
        }
        else
        {
            return objects_[id];
        }
    }

    T* getLastObject() const
    {
        return objects_.back();
    }

    unsigned int getNumberOfObjects() const
    {
        return objects_.size();
    }

    unsigned int getStorageCapacity() const
    {
        return objects_.capacity();
    }

    void setStorageCapacity(const unsigned int N)
    {
        objects_.reserve(N);
    }
    
    const typename std::vector<T*>::const_iterator begin() const
    {
        return objects_.begin();
    }

    const typename std::vector<T*>::iterator begin()
    {
        return objects_.begin();
    }
    const typename std::vector<T*>::const_iterator end() const
    {
        return objects_.end();
    }

    const typename std::vector<T*>::iterator end()
    {
        return objects_.end();
    }

private:
    std::vector<T*> objects_;
    
    unsigned int maxObjects_;

    int nextId_;    
};

#endif