PossibleContact.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, 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 POSSIBLECONTACT_H
#define POSSIBLECONTACT_H
 
#include "Particles/BaseParticle.h"
#include "Logger.h"
 
class PossibleContact
{
public:
    PossibleContact()
    {
        P1_ = nullptr;
        P2_ = nullptr;
        Next_ = nullptr;
        Prev_ = nullptr;
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
        index_ = 0;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = nullptr;
        Prev_ = nullptr;
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
        index_ = 0;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2, PossibleContact* Next)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = Next;
        Prev_ = nullptr;
        if (Next != nullptr)
            index_ = Next->getIndex() + 1;
        else
            index_ = 0;
        
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2, PossibleContact* Next, PossibleContact* Next1,
                    PossibleContact* Next2)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = Next;
        Next1_ = Next1;
        Next2_ = Next2;
        Prev_ = 0;
        Prev1_ = 0;
        Prev2_ = 0;
        if (Next != nullptr)
            index_ = Next->getIndex() + 1;
        else
            index_ = 0;
    }
    
    BaseParticle* getP1()
    {
        return P1_;
    }
    
    BaseParticle* getP2()
    {
        return P2_;
    }
    
    BaseParticle* getOtherParticle(BaseParticle* P)
    {
        if (P1_ == P)
            return P2_;
        else if (P2_ == P)
            return P1_;
        else
        {
            logger(WARN, "Particle* getOtherParticle(Particle *P), no match for % posibilities are % and %",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getNext()
    {
        return Next_;
    }
    
    PossibleContact* getNext(BaseParticle* P)
    {
        if (P1_ == P)
            return Next1_;
        else if (P2_ == P)
            return Next2_;
        else
        {
            logger(WARN, "PossibleContact* getNext(Particle* P), no match for %. Possibilities are % and %.",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getPrevious()
    {
        return Prev_;
    }
    
    PossibleContact* getPrevious(BaseParticle* P)
    {
        if (P1_ == P)
            return Prev1_;
        else if (P2_ == P)
            return Prev2_;
        else
        {
            logger(WARN, "PossibleContact* getPrevious(Particle* P), no match for %. Possibilities are % and %.",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getNext1()
    {
        return Next1_;
    }
    
    PossibleContact* getPrevious1()
    {
        return Prev1_;
    }
    
    PossibleContact* getNext2()
    {
        return Next2_;
    }
    
    PossibleContact* getPrevious2()
    {
        return Prev2_;
    }
    
    int getIndex()
    {
        return index_;
    }
    
    void setP1(BaseParticle* P1)
    {
        P1_ = P1;
    }
    
    void setP2(BaseParticle* P2)
    {
        P2_ = P2;
    }
    
    void setNextPosition(PossibleContact* Next)
    {
        Next_ = Next;
    }
    
    void setNextPosition(BaseParticle* P, PossibleContact* Next)
    {
        if (P1_ == P)
            Next1_ = Next;
        else if (P2_ == P)
            Next2_ = Next;
        else
            logger(WARN,
                   "void setNextPosition(Particle* P,PossibleContact* Next), no match for %. Possibilities are %  and % ",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
    }
    
    void setPreviousPosition(PossibleContact* Prev)
    {
        Prev_ = Prev;
    }
    
    void setPreviousPosition(BaseParticle* P, PossibleContact* Prev)
    {
        if (P1_ == P)
            Prev1_ = Prev;
        else if (P2_ == P)
            Prev2_ = Prev;
        else
            logger(WARN,
                   "void setPreviousPosition(Particle* P,PossibleContact* Prev), no match for %. Possibilities are %  and % ",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
    }
    
    void setNextPosition1(PossibleContact* Next1)
    {
        Next1_ = Next1;
    }
    
    void setPreviousPosition1(PossibleContact* Prev1)
    {
        Prev1_ = Prev1;
    }
    
    void setNextPosition2(PossibleContact* Next2)
    {
        Next2_ = Next2;
    }
    
    void setPreviousPosition2(PossibleContact* Prev2)
    {
        Prev2_ = Prev2;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const PossibleContact& o)
    {
        os << o.index_ << " between (" << o.P1_->getIndex() << "," << o.P2_->getIndex() << ")";
        return os;
    }
 
private:
    int index_;
    BaseParticle* P1_;
    BaseParticle* P2_;
    PossibleContact* Next_;
    PossibleContact* Prev_;
    PossibleContact* Next1_;
    PossibleContact* Prev1_;
    PossibleContact* Next2_;
    PossibleContact* Prev2_;
    
};
 
#endif