PIP.hpp

Go to the documentation of this file.

#pragma once
#ifndef BIL_PIP_HPP
#define BIL_PIP_HPP

#include <vector>
#include <serialization/PIPBS.hpp>
#include <xdlrc/model/PIPDirection.hpp>


namespace bil {

    class PIP {
    public:

        /**********************************************************************/
        /* CONSTRUCTION / DESTRUCTION                                         */
        /**********************************************************************/

        PIP();


        /**********************************************************************/
        /* START WIRE INDEX                                                   */
        /**********************************************************************/

        void startWireIndex(unsigned short index);

        unsigned short startWireIndex() const;


        /**********************************************************************/
        /* END WIRE INDEX                                                     */
        /**********************************************************************/

        void endWireIndex(unsigned short index);

        unsigned short endWireIndex() const;


        /**********************************************************************/
        /* DIRECTION                                                          */
        /**********************************************************************/

        void direction(PIPDirection::direction_t dir);

        PIPDirection::direction_t direction() const;


        /**********************************************************************/
        /* MODIFICATORS                                                       */
        /**********************************************************************/

        void clear();


    private:

        friend bool operator== (const PIP& pip1, const PIP& pip2);
        friend bool operator< (const PIP& pip1, const PIP& pip2);

        friend void writeBinary(const PIP& data, std::ostream& outputStream);
        friend void readBinary(PIP& data, std::istream& inputStream);

        unsigned short m_startWireIndex;
        unsigned short m_endWireIndex;
        PIPDirection::direction_t m_direction;

    };


    inline bool operator== (const PIP& pip1, const PIP& pip2)
    {
        if (pip1.m_startWireIndex != pip2.m_startWireIndex) return false;
        if (pip1.m_endWireIndex != pip2.m_endWireIndex) return false;
        return (pip1.m_direction == pip2.m_direction);
    }

    inline bool operator!= (const PIP& pip1, const PIP& pip2)
    {
        return !(operator== (pip1, pip2));
    }


    inline bool operator< (const PIP& pip1, const PIP& pip2)
    {
        if (pip1.m_startWireIndex != pip2.m_startWireIndex)
            return (pip1.m_startWireIndex < pip2.m_startWireIndex);
        if (pip1.m_endWireIndex != pip2.m_endWireIndex)
            return (pip1.m_endWireIndex < pip2.m_endWireIndex);
        return (pip1.m_direction < pip2.m_direction);
    }

    inline bool operator> (const PIP& pip1, const PIP& pip2)
    {
        return (operator< (pip2, pip1));
    }

    inline bool operator<= (const PIP& pip1, const PIP& pip2)
    {
        return !(operator> (pip1, pip2));
    }

    inline bool operator>= (const PIP& pip1, const PIP& pip2)
    {
        return !(operator< (pip1, pip2));
    }


    typedef std::vector<PIP> PIPs;

}

#endif