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

class DPMBase;

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

    BaseHandler(const BaseHandler<T>& BH);

    virtual ~BaseHandler();

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

    template<typename U>
    typename std::enable_if<!std::is_pointer<U>::value,U*>::type
    copyAndAddObject(const U& object);

    template<typename U>
    typename std::enable_if<std::is_pointer<U>::value,U>::type
    copyAndAddObject(const U object);

    virtual void addObject(T* object);

    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);

    void setId(T* object,unsigned int id) 
    {
        object->setId(id);
        if (nextId_<=id)
        {
            nextId_ = id+1;
        }
    }

    DPMBase* getDPMBase();

    DPMBase* getDPMBase() const;
    
    virtual std::string getName() const = 0;
    
    virtual void writeVTK(){};

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

    unsigned int nextId_;

    DPMBase* DPMBase_;
};

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

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

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

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

template<typename T>
template<typename U>
typename std::enable_if<!std::is_pointer<U>::value,U*>::type
BaseHandler<T>::copyAndAddObject(const U& object)
{
    U* oCopy = object.copy();
    addObject(oCopy);
    return oCopy;
}

template<typename T>
template<typename U>
typename std::enable_if<std::is_pointer<U>::value,U>::type
BaseHandler<T>::copyAndAddObject(const U object)
{
    return copyAndAddObject(*object);
}

template<typename T>
void BaseHandler<T>::addObject(T* object)
{
    objects_.push_back(object);
    //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<typename T>
void BaseHandler<T>::removeObject(const unsigned int index)
{
    logger.assert_always(index < getNumberOfObjects(),
                         "In: void %::removeOject(const unsigned int index) const, "
                         "no object exists with index %, number of objects is %",
                         getName(), index, getNumberOfObjects());
    
    //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.
    const unsigned int lastIndex = objects_.size() - 1;
  
    //So, step one, retrieve the pointer
    T* const objectToDelete = objects_[index];

    if (index != lastIndex) //Are we not the last object?
    {
      //well.. let's swap.
      T* const 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 clear it from the backing container.
    objects_.pop_back();
    //And _NOW_ we delete it.
    delete objectToDelete;
      
}

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

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

template<typename 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);
    setStorageCapacity(N);
    for (unsigned int i = 0; i < N; i++)
    {
        readObject(is);
    }
}

template<typename T>
T* BaseHandler<T>::getObjectById(const unsigned int id)
{
    // Usually, the id and the index into the backing storage matches
    // So check this position 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<typename T>
T* BaseHandler<T>::getObject(const unsigned int index)
{
    logger.assert(index < getNumberOfObjects(),
                  "[%::getObject()] Object couldn't be found because index (%) is higher than number of objects (%).",
                  getName(), index, getNumberOfObjects());
    
    return objects_[index];
}

template<typename T>
const T* BaseHandler<T>::getObject(const unsigned int index) const
{
    logger.assert(index < getNumberOfObjects(),
                  "[%::getObject() const] Object couldn't be found because index (%) is higher than number of objects (%).",
                  getName(), index, getNumberOfObjects());
    return objects_[index];
}

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

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

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

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

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

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

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

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

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

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

template<typename T>
DPMBase* BaseHandler<T>::getDPMBase()
{
    logger.assert(DPMBase_!= nullptr,"[BaseHandler::getDPMBase()] in Object* %: pointer to DPMBase class is not set.", getName());
    return DPMBase_;
}

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