include/fwData/Resection.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2018.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#pragma once

#include "fwData/config.hpp"
#include "fwData/factory/new.hpp"
#include "fwData/PlaneList.hpp"
#include "fwData/Reconstruction.hpp"

#include <fwCom/Signal.hpp>
#include <fwCom/Signals.hpp>

#include <vector>

fwCampAutoDeclareDataMacro((fwData)(Resection), FWDATA_API);
namespace fwData
{
class FWDATA_CLASS_API Resection : public ::fwData::Object
{

public:
    fwCoreClassDefinitionsWithFactoryMacro( (Resection)(::fwData::Object),
                                            (()), ::fwData::factory::New< Resection >);

    fwCampMakeFriendDataMacro((fwData)(Resection));

    typedef std::vector< ::fwData::Reconstruction::sptr > ResectionInputs;
    typedef std::vector< ::fwData::Reconstruction::sptr > ResectionOutputs;

    FWDATA_API Resection(::fwData::Object::Key key);

    FWDATA_API virtual ~Resection();

    FWDATA_API void shallowCopy( const Object::csptr& _source ) override;

    FWDATA_API void cachedDeepCopy(const Object::csptr& _source, DeepCopyCacheType& cache) override;

    ::fwData::PlaneList::sptr& getPlaneList();
    const ::fwData::PlaneList::sptr& getPlaneList() const;
    void setPlaneList (const ::fwData::PlaneList::sptr& _planeList);

    ResectionInputs& getInputs ();
    const ResectionInputs& getInputs () const;
    void setInputs (const ResectionInputs& _vInputs);

    ResectionOutputs& getOutputs ();
    const ResectionOutputs& getOutputs () const;
    void setOutputs (const ResectionOutputs& _vOutputs);

    bool  getIsSafePart () const;
    void setIsSafePart (const bool _isSafePart);

    std::string& getName ();
    const std::string& getName () const;
    void setName (const std::string& _name);


    bool  getIsVisible () const;
    void setIsVisible (const bool _isVisible);


    bool  getIsValid () const;
    void setIsValid (const bool _isValid);


    /***
     * @name Signals
     * @{
     */

    typedef ::fwCom::Signal< void () > ReconstructionAddedSignalType;

    FWDATA_API static const ::fwCom::Signals::SignalKeyType s_RECONSTRUCTION_ADDED_SIG;

    typedef ::fwCom::Signal< void () > VisibilityModifiedSignalType;

    FWDATA_API static const ::fwCom::Signals::SignalKeyType s_VISIBILITY_MODIFIED_SIG;

protected:

    std::string m_name;

    ::fwData::PlaneList::sptr m_planeList;

    ResectionInputs m_vInputs;

    ResectionOutputs m_vOutputs;

    bool m_isSafePart;

    bool m_isValid;

    bool m_isVisible;

private:

    ReconstructionAddedSignalType::sptr m_sigReconstructionAdded;

    VisibilityModifiedSignalType::sptr m_sigVisibilityModified;
}; // end class Resection

//-----------------------------------------------------------------------------

inline ::fwData::PlaneList::sptr& Resection::getPlaneList()
{
    return m_planeList;
}

//-----------------------------------------------------------------------------

inline const ::fwData::PlaneList::sptr& Resection::getPlaneList() const
{
    return m_planeList;
}

//-----------------------------------------------------------------------------

inline void Resection::setPlaneList (const ::fwData::PlaneList::sptr& _planeList)
{
    m_planeList = _planeList;
}

//-----------------------------------------------------------------------------

inline Resection::ResectionInputs& Resection::getInputs ()
{
    return m_vInputs;
}

//-----------------------------------------------------------------------------

inline const Resection::ResectionInputs& Resection::getInputs () const
{
    return m_vInputs;
}

//-----------------------------------------------------------------------------

inline void Resection::setInputs (const Resection::ResectionInputs& _vInputs)
{
    m_vInputs = _vInputs;
}

//-----------------------------------------------------------------------------

inline Resection::ResectionOutputs& Resection::getOutputs ()
{
    return m_vOutputs;
}

//-----------------------------------------------------------------------------

inline const Resection::ResectionOutputs& Resection::getOutputs () const
{
    return m_vOutputs;
}

//-----------------------------------------------------------------------------

inline void Resection::setOutputs (const Resection::ResectionOutputs& _vOutputs)
{
    m_vOutputs = _vOutputs;
}

//-----------------------------------------------------------------------------

inline bool Resection::getIsSafePart () const
{
    return m_isSafePart;
}

//-----------------------------------------------------------------------------

inline void Resection::setIsSafePart (const bool _isSafePart)
{
    m_isSafePart = _isSafePart;
}

//-----------------------------------------------------------------------------

inline std::string& Resection::getName ()
{
    return m_name;
}

//-----------------------------------------------------------------------------

inline const std::string& Resection::getName () const
{
    return m_name;
}

//-----------------------------------------------------------------------------

inline void Resection::setName (const std::string& _name)
{
    m_name = _name;
}

//-----------------------------------------------------------------------------

inline bool Resection::getIsVisible () const
{
    return m_isVisible;
}

//-----------------------------------------------------------------------------

inline void Resection::setIsVisible (const bool _isVisible)
{
    m_isVisible = _isVisible;
}

//-----------------------------------------------------------------------------

inline bool Resection::getIsValid () const
{
    return m_isValid;
}

//-----------------------------------------------------------------------------

inline void Resection::setIsValid (const bool _isValid)
{
    m_isValid = _isValid;
}

//-----------------------------------------------------------------------------

} // end namespace fwData