BaseHandler.h

Go to the documentation of this file.

//Copyright (c) 2013-2020, 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 <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);
    
    template<typename U>
    typename std::enable_if<!std::is_pointer<U>::value, U*>::type
    copyAndAddGhostObject(const U& object);
    
    template<typename U>
    typename std::enable_if<std::is_pointer<U>::value, U>::type
    copyAndAddGhostObject(const U object);
    
    virtual void addExistingObject(T* O);
    
    virtual void addObject(T* object);
    
    virtual void addGhostObject(T* O);
    
    void removeIf(const std::function<bool(T*)> cond);
    
    virtual void removeObject(unsigned const int index);
    
    void removeLastObject();
    
    virtual void clear();
    
    virtual void readAndAddObject(std::istream& is) = 0;
    
    void read(std::istream& is);
    
    T* getObjectById(const unsigned int id);
    
    std::vector<T*> getObjectsById(const unsigned int id);
    
    T* getObject(const unsigned int id);
    
    const T* getObject(const unsigned int id) const;
    
    T* getLastObject();
    
    const T* getLastObject() const;
    
    virtual unsigned int getNumberOfObjects() const;
    
    unsigned int getSize() const;
    
    unsigned int getStorageCapacity() const;
    
    void setStorageCapacity(const unsigned int N);
    
    void resize(const unsigned int N, const T& obj);
    
    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;
        }
    }
    
    /*
     * \brief This function updates the iD counter by one
     * \details Function used in parallel to keep the Id's unique over all processors
     */
    void increaseId()
    {
        nextId_++;
    }
    
    unsigned int getNextId()
    {
        return nextId_;
    }
    
    void setNextId(unsigned int id)
    {
        nextId_ = id;
    }
    
    DPMBase* getDPMBase();
    
    DPMBase* getDPMBase() const;
    
    virtual std::string getName() const = 0;
    
    [[deprecated]]
    virtual void writeVTK() const
    {};
    
    unsigned getNextGroupId() { return nextGroupId_++; }
    
protected:
    std::vector<T*> objects_;

private:
    unsigned int maxObjects_;
    
    unsigned int nextId_;
    
    unsigned nextGroupId_ = 1;

    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<class T>
template<class U>
typename std::enable_if<!std::is_pointer<U>::value, U*>::type
BaseHandler<T>::copyAndAddGhostObject(const U& object)
{
    U* oCopy = object.copy();
    addGhostObject(oCopy);
    return oCopy;
}

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

template<class T>
void BaseHandler<T>::addExistingObject(T* O)
{
    objects_.push_back(O);
    //Set the index of the particle
    getLastObject()->setIndex(getSize() - 1);
    //Adjust the nextId_ value
    if (O->getId() + 1 > nextId_)
    {
        nextId_ = O->getId() + 1;
    }
}

template<class T>
void BaseHandler<T>::addObject(T* object)
{
    objects_.push_back(object);
    //Set the index of the particle
    getLastObject()->setIndex(getSize() - 1);
    //set the non changing particle identifier
    getLastObject()->setId(nextId_);
    //Update Id for next particle
    nextId_++;
}

template<class T>
void BaseHandler<T>::addGhostObject(T* O)
{
    objects_.push_back(O);
    //Set the index of the particle
    getLastObject()->setIndex(getSize() - 1);
}

//\todo should this function ever be used?
template<class T>
void BaseHandler<T>::removeIf(const std::function<bool(T*)> cond)
{
    for (int i = 0; i < objects_.size(); ++i) {
        if (cond(objects_[i]))
        {
            //objects_(i)->actionsOnErase();
            removeObject(i);
            --i;
        }
    }
}

template<typename T>
void BaseHandler<T>::removeObject(const unsigned int index)
{
    logger.assert(index < getSize(),
                  "In: void %::removeObject(const unsigned int index) const, "
                  "no object exists with index %, number of objects is %",
                  getName(), index, getSize());
    
    //Removing a particle within the list is not efficient.
    //Swap with last element and then perform the deletion
    const unsigned int lastIndex = objects_.size() - 1;
    
    T* const objectToDelete = objects_[index];
    
    //No swapping required if it is the last object
    if (index != lastIndex)
    {
        
        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 (getSize() == 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;
    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++)
    {
        readAndAddObject(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;
    }
#ifndef MERCURY_USE_MPI
    logger(ERROR, "[BaseHandler::getObjectById()] in Object* %: Object with ID % could not be found.", getName(), id);
#endif
    return nullptr;
}

template<typename T>
std::vector<T*> BaseHandler<T>::getObjectsById(const unsigned int id)
{
    std::vector<T*> list;
    for (T* obj : objects_)
    {
        if (obj->getId() == id)
        {
            list.push_back(obj);
        }
    }
#ifndef MERCURY_USE_MPI
    logger(ERROR, "[BaseHandler::getObjectById()] in Object* %: Object with ID % could not be found.", getName(), id);
#endif
    return list;
    
}

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

template<typename T>
const T* BaseHandler<T>::getObject(const unsigned int index) const
{
    logger.assert(index < getSize(),
                  "[%::getObject() const] Object couldn't be found because index (%) is higher than number of objects (%).",
                  getName(), index, getSize());
    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<class T>
unsigned int BaseHandler<T>::getSize() 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<class T>
void BaseHandler<T>::resize(const unsigned int N, const T& obj)
{
    //objects_.resize(N,obj); //doesn't work because the handler stores pointers only (data needs to be allocated);
    while (getSize() < N)
        copyAndAddObject(obj);
    while (getSize() > N)
        removeLastObject();
}

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()
{
    return DPMBase_;
}

template<typename T>
DPMBase* BaseHandler<T>::getDPMBase() const
{
    return DPMBase_;
}

#endif