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>
#include "Math/Helpers.h"
#include "Logger.h"

class DPMBase;

template<class T>
class BaseHandler
{
public:
    BaseHandler();

    BaseHandler(const BaseHandler<T>& BH);

    virtual ~BaseHandler();

    void copyContentsFromOtherHandler(const BaseHandler<T>& BH);

    template<typename U>
    U* copyAndAddObject(const U& O);

    template<typename U>
    U* copyAndAddObject(U* O);

    virtual void addObject(T* O);

    virtual void removeObject(unsigned const int id);

    void removeLastObject();

    void clear();

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

    void read(std::istream& is);

    T* getObjectById(const unsigned int id);

    T* getObject(const unsigned int id);

    const T* getObject(const unsigned int id) const;

    T* getLastObject();

    const T* getLastObject() const;

    unsigned int getNumberOfObjects() const;

    unsigned int getStorageCapacity() const;

    void setStorageCapacity(const unsigned int N);

    const typename std::vector<T*>::const_iterator begin() const;

    const typename std::vector<T*>::iterator begin();

    const typename std::vector<T*>::const_iterator end() const;

    const typename std::vector<T*>::iterator end();

    void setDPMBase(DPMBase* DPMBase);

    DPMBase* getDPMBase();

    DPMBase* getDPMBase() const;
    
    virtual std::string getName() const = 0;

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

    unsigned int nextId_;

    DPMBase* DPMBase_;
};

template<class T> BaseHandler<T>::BaseHandler()
{
    DPMBase_ = nullptr;
    clear();
    logger(DEBUG, "Basehandler<T>::BaseHandler() finished");
}

template<class T> BaseHandler<T>::BaseHandler(const BaseHandler<T>& BH)
{
    DPMBase_ = nullptr;
    clear();
    copyContentsFromOtherHandler(BH);
    logger(DEBUG,"BaseHandler<T>::BaseHandler(const BaseHandler &BH) finished");
}

template<class T> BaseHandler<T>::~BaseHandler()
{
    clear();
    logger(DEBUG, "BaseHandler<T>::~BaseHandler() finished");
}

template<class T> void BaseHandler<T>::copyContentsFromOtherHandler(const BaseHandler<T>& BH)
{
    for (auto obj : BH.objects_) 
    {
        addObject(obj->copy());
    }
}

template<class T> template<class U> U* BaseHandler<T>::copyAndAddObject(const U& O)
{
    U* oCopy = O.copy();
    addObject(oCopy);
    return oCopy;
}

template<class T> template<class U> U* BaseHandler<T>::copyAndAddObject(U* O)
{
    U* oCopy = O->copy();
    addObject(oCopy);
    return oCopy;
}

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

template<class T> void BaseHandler<T>::removeObject(unsigned const int index)
{
    if (index >= getNumberOfObjects())
    {
        logger(ERROR, "In: void %::removeOject(const unsigned int index) const, no object exists with index %, number of objects is %", getName(), index, getNumberOfObjects());
        return;
    }
    
    //Okay, this function deletes the particle. Now, the problem is that
    //particles store their position in the handler (@dducks: do they?)
    //which means that we would absolutely destroy performance if we took
    //something out in the middle. Now, what we'll do is swap our particle
    //with the last one (in case it already is, it is invariant); then
    //remove the last one.
    //So, we want the last index.
    std::size_t lastIndex = objects_.size() - 1;
  
    //So, step one, retrieve the pointer
    T* objectToDelete = objects_[index];

    if (index != lastIndex) //Are we not the last object?
    {
      //well.. let's swap.
      T* objectToMove = objects_[lastIndex];

      objects_[index] = objectToMove; //place it back
      objects_[lastIndex] = objectToDelete; //Just to make sure.

      //and notify it of the change.
      objects_[index]->moveInHandler(index);
      //Even though we are going to delete this particle,
      //we still need to keep it consistent.
      objects_[lastIndex]->moveInHandler(lastIndex);
    }
    
    //And _NOW_ we delete it.
    delete objectToDelete;
      
    //And clear it from the backing container.
    objects_.pop_back();
}

template<class T> void BaseHandler<T>::removeLastObject()
{
    if (getNumberOfObjects() == 0)
    {
        logger(WARN, "In: void %::removeLastObject, no Object exists in this BaseHandler.", getName());
        return;
    }
    //Physically removes Object
    delete objects_.back();
    //Remove the (now double) reference to that last Object
    objects_.pop_back();
}

template<class T> void BaseHandler<T>::clear()
{
    
    for (auto obj : objects_) 
    {
        delete obj;
    }
    objects_.clear();
    
    nextId_ = 0;
    maxObjects_ = 0;
}

template<class T> void BaseHandler<T>::read(std::istream& is)
{
    clear();
    unsigned int N;
    std::string dummy;
    is >> dummy;
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    helpers::getLineFromStringStream(is, line);
    line >> N;
    logger(VERBOSE, "In %::read(is): reading in % objects.", getName(), N);
    for (unsigned int i = 0; i < N; i++)
    {
        readObject(is);
    }
}

template<class T> T* BaseHandler<T>::getObjectById(const unsigned int id)
{
    // Usually, the id and the index into the backing storage matches
    // So check this postion first!
    // dducks: Can't we guarantee more? That should speed up searches. 
    if (id < objects_.size() && objects_[id]->getId() == id)
    {
        return objects_[id]; //There is a hit, return early
    }
    
    for (T* obj : objects_ ) //Search for the correct id, since it wasn't where
    {                        // we expected it. Just use a linear search..
        if (obj->getId() == id) //Found it, so return!
            return obj;
    }
    logger(ERROR, "[BaseHandler::getObjectById()] in Object* %: Object with ID % could not be found.", getName(), id);
    return nullptr;
}

template<class T> T* BaseHandler<T>::getObject(const unsigned int index)
{
#ifdef NDEBUG
    return objects_[index];
#else
    if (index >= getNumberOfObjects())
    {
        logger(ERROR, "[BaseHandler::getObject(const unsigned int index)] in Object* %: Object couldn't be found because index (%) is higher than number of objects.", getName(), index);
        return nullptr;
    }
    else
    {
        return objects_[index];
    }
#endif
}

template<class T> const T* BaseHandler<T>::getObject(const unsigned int index) const
{
#ifdef NDEBUG
    return objects_[index];
#else
    if (index >= getNumberOfObjects())
    {
        logger(ERROR, "[BaseHandler::getObject(const unsigned int index) const] in Object* %: No object exist with index % number of objects is %", getName(), index, getNumberOfObjects());
        return nullptr;
    }
    else
    {
        return objects_[index];
    }
#endif
}

template<class T> T* BaseHandler<T>::getLastObject()
{
    return objects_.back();
}

template<class T> const T* BaseHandler<T>::getLastObject() const
{
    return objects_.back();
}

template<class T> unsigned int BaseHandler<T>::getNumberOfObjects() const
{
    return objects_.size();
}

template<class T> unsigned int BaseHandler<T>::getStorageCapacity() const
{
    return objects_.capacity();
}

template<class T> void BaseHandler<T>::setStorageCapacity(const unsigned int N)
{
    objects_.reserve(N);
}

template<class T> const typename std::vector<T*>::const_iterator BaseHandler<T>::begin() const
{
    return objects_.begin();
}

template<class T> const typename std::vector<T*>::iterator BaseHandler<T>::begin()
{
    return objects_.begin();
}

template<class T> const typename std::vector<T*>::const_iterator BaseHandler<T>::end() const
{
    return objects_.end();
}

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

template<class T> void BaseHandler<T>::setDPMBase(DPMBase* DPMBase)
{
    DPMBase_ = DPMBase;
}

template<class T> DPMBase* BaseHandler<T>::getDPMBase()
{
#ifdef NDEBUG
    return DPMBase_;
#else
    if (DPMBase_ == nullptr)
    {
        logger(ERROR, "[BaseHandler::getDPMBase()] in Object* %: pointer to DPMBase class is not set.", getName());
    }
    return DPMBase_;
#endif
}

template<class T> DPMBase* BaseHandler<T>::getDPMBase() const
{
#ifdef NDEBUG
    return DPMBase_;
#else
    if (DPMBase_ == nullptr)
    {
        logger(ERROR, "[BaseHandler::getDPMBase() const] in Object* %: pointer to DPMBase class is not set.", getName());
    }
    return DPMBase_;
#endif
}
#endif