TYInfrastructure.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
/*
 *
 */
 
#ifndef __TY_INFRASTRUCTURE__
#define __TY_INFRASTRUCTURE__
 
#include "Tympan/models/business/infrastructure/TYBatiment.h"
#include "Tympan/models/business/infrastructure/TYReseauTransport.h"
#if WITH_NMPB
    #include "Tympan/models/business/infrastructure/TYRoute.h"
#endif
#include "Tympan/models/business/acoustic/TYUserSourcePonctuelle.h"
 
class TYInfrastructure : public TYElement
{
    OPROTODECL(TYInfrastructure)
    TY_EXTENSION_DECL_ONLY(TYInfrastructure)
    TY_EXT_GRAPHIC_DECL_ONLY(TYInfrastructure)
 
    // Methodes
public:
    TYInfrastructure();
    TYInfrastructure(const TYInfrastructure& other);
    virtual ~TYInfrastructure();
 
    TYInfrastructure& operator=(const TYInfrastructure& other);
    bool operator==(const TYInfrastructure& other) const;
    bool operator!=(const TYInfrastructure& other) const;
 
    virtual bool deepCopy(const TYElement* pOther, bool copyId = true, bool pUseCopyTag = false);
 
    virtual std::string toString() const;
 
    virtual DOM_Element toXML(DOM_Element& domElement);
    virtual int fromXML(DOM_Element domElement);
 
    virtual void getChilds(LPTYElementArray& childs, bool recursif = true);
 
 
 
    virtual void updateCurrentCalcul(TYListID& listID, bool recursif = true);
 
    TYProjet* getProjet();
 
    virtual void reparent();
 
    void purge();
 
#if WITH_NMPB
    TYTabRouteGeoNode& getListRoute()
    {
        return _listRoute;
    }
 
    const TYTabRouteGeoNode& getListRoute() const
    {
        return _listRoute;
    }
 
    void setListRoute(const TYTabRouteGeoNode& list)
    {
        _listRoute = list;
    }
#endif
 
    void concatInfra(const TYInfrastructure* infra);
 
#if WITH_NMPB
    bool addRoute(LPTYRouteGeoNode pRouteGeoNode);
 
    bool addRoute(LPTYRoute pRoute);
 
    bool remRoute(const LPTYRouteGeoNode pRouteGeoNode);
 
    bool remRoute(const LPTYRoute pRoute);
 
    bool remRoute(QString idRoute);
 
    void remAllRoute();
 
    LPTYRoute getRoute(int index)
    {
        return TYRoute::safeDownCast(_listRoute.at(index)->getElement());
    }
 
    LPTYRouteGeoNode findRoute(const LPTYRoute pRoute);
#endif
 
    TYTabReseauTransportGeoNode& getListResTrans()
    {
        return _listResTrans;
    }
 
    const TYTabReseauTransportGeoNode& getListResTrans() const
    {
        return _listResTrans;
    }
 
    void setListResTrans(const TYTabReseauTransportGeoNode& list)
    {
        _listResTrans = list;
    }
 
    bool addResTrans(LPTYReseauTransportGeoNode pResTransGeoNode);
 
    bool addResTrans(LPTYReseauTransport pResTrans);
 
    bool remResTrans(const LPTYReseauTransportGeoNode pResTransGeoNode);
 
    bool remResTrans(const LPTYReseauTransport pResTrans);
 
    bool remResTrans(QString idResTrans);
 
    void remAllResTrans();
 
    LPTYReseauTransport getResTrans(int index)
    {
        return TYReseauTransport::safeDownCast(_listResTrans.at(index)->getElement());
    }
 
    LPTYReseauTransportGeoNode findResTrans(const LPTYReseauTransport pResTrans);
 
    TYTabBatimentGeoNode& getListBatiment()
    {
        return _listBatiment;
    }
 
    const TYTabBatimentGeoNode& getListBatiment() const
    {
        return _listBatiment;
    }
 
    void setListBatiment(const TYTabBatimentGeoNode& list)
    {
        _listBatiment = list;
    }
 
    bool addBatiment(LPTYBatimentGeoNode pBatimentGeoNode);
 
    bool addBatiment(LPTYBatiment pBatiment, const TYRepere& pos);
 
    bool remBatiment(const LPTYBatimentGeoNode pBatimentGeoNode);
 
    bool remBatiment(const LPTYBatiment pBatiment);
 
    bool remBatiment(QString idBatiment);
 
    void remAllBatiment();
 
    LPTYBatimentGeoNode getBatiment(int index)
    {
        return _listBatiment.at(index);
    }
 
    LPTYBatimentGeoNode findBatiment(const LPTYBatiment pBatiment);
 
    TYTabMachineGeoNode& getListMachine()
    {
        return _listMachine;
    }
 
    const TYTabMachineGeoNode& getListMachine() const
    {
        return _listMachine;
    }
 
    void setListMachine(const TYTabMachineGeoNode& list)
    {
        _listMachine = list;
    }
 
    bool addMachine(LPTYMachineGeoNode pMachineGeoNode);
 
    bool addMachine(LPTYMachine pMachine, const TYRepere& pos);
 
    bool remMachine(const LPTYMachine pMachine);
 
    bool remMachine(const LPTYMachineGeoNode pMachineGeoNode);
 
    bool remMachine(QString idMachine);
 
    void remAllMachine();
 
    LPTYMachineGeoNode getMachine(int index)
    {
        return _listMachine.at(index);
    }
 
    LPTYMachineGeoNode findMachine(const LPTYMachine pMachine);
 
    TYTabUserSourcePonctuelleGeoNode& getSrcs()
    {
        return _listSrc;
    }
 
    const TYTabUserSourcePonctuelleGeoNode& getSrcs() const
    {
        return _listSrc;
    }
 
    void setSrcs(const TYTabUserSourcePonctuelleGeoNode& list)
    {
        _listSrc = list;
    }
 
    bool addSrc(LPTYUserSourcePonctuelle pSrc);
 
    bool addSrc(LPTYUserSourcePonctuelleGeoNode pSrcGeoNode);
 
    bool remSrc(const LPTYUserSourcePonctuelle pSrc);
 
    bool remSrc(const LPTYUserSourcePonctuelleGeoNode pSrcGeoNode);
 
    bool remSrc(QString idSrc);
 
    void remAllSrc();
 
    LPTYUserSourcePonctuelleGeoNode getSrc(int index)
    {
        return _listSrc.at(index);
    }
 
    LPTYUserSourcePonctuelleGeoNode findSrc(const LPTYUserSourcePonctuelle pSrc);
 
    void getAllSrcs(const TYCalcul* pCalcul, TYMapElementTabSources& mapElementSrcs);
 
    bool updateAcoustic(const TYCalcul* pCalcul, const bool& force = false);
 
    void clean();
 
    std::vector<LPTYElement> getTabElemNOk()
    {
        return _tabUpdateNOk;
    }
 
    bool addToCalcul(TYGeometryNode* pNode);
 
    bool addToCalcul();
 
    bool remFromCalcul();
 
    // Membres
protected:
#if WITH_NMPB
    TYTabRouteGeoNode _listRoute;
#endif
    TYTabReseauTransportGeoNode _listResTrans;
 
    TYTabBatimentGeoNode _listBatiment;
 
    TYTabMachineGeoNode _listMachine;
 
    TYTabUserSourcePonctuelleGeoNode _listSrc;
 
    std::vector<LPTYElement> _tabUpdateNOk;
};
 
typedef TYGeometryNode TYInfrastructureGeoNode;
typedef SmartPtr<TYInfrastructureGeoNode> LPTYInfrastructureGeoNode;
typedef std::vector<LPTYInfrastructureGeoNode> TYTabInfrastructureGeoNode;
 
#endif // __TY_INFRASTRUCTURE__