Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	src/Representation/RenderProject.cpp	Lines:	300	466	64.4 %
Date:	2023-10-11 10:52:07	Branches:	6	18	33.3 %

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/




#include "RenderProject.h"

///Constructor of class ComputingCenter
ComputingCenter::ComputingCenter(){
	initialisationComputingCenter();
}

///Copy Constructor of class ComputingCenter
/**	@param other : ComputingCenter we want ot copy
*/
ComputingCenter::ComputingCenter(const ComputingCenter & other){
	copyComputingCenter(other);
}

///Destructor of class ComputingCenter
ComputingCenter::~ComputingCenter(){

}

///Operator = of class ComputingCenter
/**	@param other : ComputingCenter we want ot copy
 * 	@return copied class ComputingCenter
*/
ComputingCenter & ComputingCenter::operator = (const ComputingCenter & other){
	copyComputingCenter(other);
	return *this;
}

///Sets the computingCenterConnection of the ComputingCenter
/**	@param computingCenterConnection : computingCenterConnection of the ComputingCenter
*/
void ComputingCenter::setComputingCenterConnection(const std::string & computingCenterConnection){
	p_computingCenterConnection = computingCenterConnection;
}

///Sets the remoteWorkingDirectory of the ComputingCenter
/**	@param remoteWorkingDirectory : remoteWorkingDirectory of the ComputingCenter
*/
void ComputingCenter::setRemoteWorkingDirectory(const std::string & remoteWorkingDirectory){
	p_remoteWorkingDirectory = remoteWorkingDirectory;
}

///Sets the remoteContainerDirectory of the ComputingCenter
/**	@param remoteContainerDirectory : remoteContainerDirectory of the ComputingCenter
*/
void ComputingCenter::setRemoteContainerDirectory(const std::string & remoteContainerDirectory){
	p_remoteContainerDirectory = remoteContainerDirectory;
}

///Sets the notification of the ComputingCenter
/**	@param notification : notification of the ComputingCenter
*/
void ComputingCenter::setNotification(const std::string & notification){
	p_notification = notification;
}

///Sets the notifyUser of the ComputingCenter
/**	@param notifyUser : notifyUser of the ComputingCenter
*/
void ComputingCenter::setNotifyUser(const std::string & notifyUser){
	p_notifyUser = notifyUser;
}

///Gets the computingCenterConnection of the ComputingCenter
/**	@return computingCenterConnection of the ComputingCenter
*/
const std::string & ComputingCenter::getComputingCenterConnection() const{
	return p_computingCenterConnection;
}

///Gets the computingCenterConnection of the ComputingCenter
/**	@return computingCenterConnection of the ComputingCenter
*/
std::string & ComputingCenter::getComputingCenterConnection(){
	return p_computingCenterConnection;
}

///Gets the remoteWorkingDirectory of the ComputingCenter
/**	@return remoteWorkingDirectory of the ComputingCenter
*/
const std::string & ComputingCenter::getRemoteWorkingDirectory() const{
	return p_remoteWorkingDirectory;
}

///Gets the remoteWorkingDirectory of the ComputingCenter
/**	@return remoteWorkingDirectory of the ComputingCenter
*/
std::string & ComputingCenter::getRemoteWorkingDirectory(){
	return p_remoteWorkingDirectory;
}

///Gets the remoteContainerDirectory of the ComputingCenter
/**	@return remoteContainerDirectory of the ComputingCenter
*/
const std::string & ComputingCenter::getRemoteContainerDirectory() const{
	return p_remoteContainerDirectory;
}

///Gets the remoteContainerDirectory of the ComputingCenter
/**	@return remoteContainerDirectory of the ComputingCenter
*/
std::string & ComputingCenter::getRemoteContainerDirectory(){
	return p_remoteContainerDirectory;
}

///Gets the notification of the ComputingCenter
/**	@return notification of the ComputingCenter
*/
const std::string & ComputingCenter::getNotification() const{
	return p_notification;
}

///Gets the notification of the ComputingCenter
/**	@return notification of the ComputingCenter
*/
std::string & ComputingCenter::getNotification(){
	return p_notification;
}

///Gets the notifyUser of the ComputingCenter
/**	@return notifyUser of the ComputingCenter
*/
const std::string & ComputingCenter::getNotifyUser() const{
	return p_notifyUser;
}

///Gets the notifyUser of the ComputingCenter
/**	@return notifyUser of the ComputingCenter
*/
std::string & ComputingCenter::getNotifyUser(){
	return p_notifyUser;
}

///Copy Function of class ComputingCenter
/**	@param other : ComputingCenter we want ot copy
*/
void ComputingCenter::copyComputingCenter(const ComputingCenter & other){
	p_computingCenterConnection = other.p_computingCenterConnection;
	p_remoteWorkingDirectory = other.p_remoteWorkingDirectory;
	p_remoteContainerDirectory = other.p_remoteContainerDirectory;
	p_notification = other.p_notification;
	p_notifyUser = other.p_notifyUser;
}

///Initialisation Function of class ComputingCenter
void ComputingCenter::initialisationComputingCenter(){
	p_computingCenterConnection = "";
	p_remoteWorkingDirectory = "";
	p_remoteContainerDirectory = "";
	p_notification = "";
	p_notifyUser = "";
}

///Constructor of class Container
Container::Container(){
	initialisationContainer();
}

///Copy Constructor of class Container
/**	@param other : Container we want ot copy
*/
Container::Container(const Container & other){
	copyContainer(other);
}

///Destructor of class Container
Container::~Container(){

}

///Operator = of class Container
/**	@param other : Container we want ot copy
 * 	@return copied class Container
*/
Container & Container::operator = (const Container & other){
	copyContainer(other);
	return *this;
}

///Sets the url of the Container
/**	@param url : url of the Container
*/
void Container::setUrl(const std::string & url){
	p_url = url;
}

///Sets the containerFilename of the Container
/**	@param containerFilename : containerFilename of the Container
*/
void Container::setContainerFilename(const std::string & containerFilename){
	p_containerFilename = containerFilename;
}

///Sets the containerRecipe of the Container
/**	@param containerRecipe : containerRecipe of the Container
*/
void Container::setContainerRecipe(const std::string & containerRecipe){
	p_containerRecipe = containerRecipe;
}

///Sets the containerName of the Container
/**	@param containerName : containerName of the Container
*/
void Container::setContainerName(const std::string & containerName){
	p_containerName = containerName;
}

///Gets the url of the Container
/**	@return url of the Container
*/
const std::string & Container::getUrl() const{
	return p_url;
}

///Gets the url of the Container
/**	@return url of the Container
*/
std::string & Container::getUrl(){
	return p_url;
}

///Gets the containerFilename of the Container
/**	@return containerFilename of the Container
*/
const std::string & Container::getContainerFilename() const{
	return p_containerFilename;
}

///Gets the containerFilename of the Container
/**	@return containerFilename of the Container
*/
std::string & Container::getContainerFilename(){
	return p_containerFilename;
}

///Gets the containerRecipe of the Container
/**	@return containerRecipe of the Container
*/
const std::string & Container::getContainerRecipe() const{
	return p_containerRecipe;
}

///Gets the containerRecipe of the Container
/**	@return containerRecipe of the Container
*/
std::string & Container::getContainerRecipe(){
	return p_containerRecipe;
}

///Gets the containerName of the Container
/**	@return containerName of the Container
*/
const std::string & Container::getContainerName() const{
	return p_containerName;
}

///Gets the containerName of the Container
/**	@return containerName of the Container
*/
std::string & Container::getContainerName(){
	return p_containerName;
}

///Copy Function of class Container
/**	@param other : Container we want ot copy
*/
void Container::copyContainer(const Container & other){
	p_url = other.p_url;
	p_containerFilename = other.p_containerFilename;
	p_containerRecipe = other.p_containerRecipe;
	p_containerName = other.p_containerName;
}

///Initialisation Function of class Container
void Container::initialisationContainer(){
	p_url = "";
	p_containerFilename = "";
	p_containerRecipe = "";
	p_containerName = "";
}

///Constructor of class Scene
Scene::Scene(){
	initialisationScene();
}

///Copy Constructor of class Scene
/**	@param other : Scene we want ot copy
*/
Scene::Scene(const Scene & other){
	copyScene(other);
}

///Destructor of class Scene
Scene::~Scene(){

}

///Operator = of class Scene
/**	@param other : Scene we want ot copy
 * 	@return copied class Scene
*/
Scene & Scene::operator = (const Scene & other){
	copyScene(other);
	return *this;
}

///Sets the workingDirectory of the Scene
/**	@param workingDirectory : workingDirectory of the Scene
*/
void Scene::setWorkingDirectory(const std::string & workingDirectory){
	p_workingDirectory = workingDirectory;
}

///Sets the custumScript of the Scene
/**	@param custumScript : custumScript of the Scene
*/
void Scene::setCustumScript(const std::string & custumScript){
	p_custumScript = custumScript;
}

///Sets the name of the Scene
/**	@param name : name of the Scene
*/
void Scene::setName(const std::string & name){
	p_name = name;
}

///Sets the blenderInputFile of the Scene
/**	@param blenderInputFile : blenderInputFile of the Scene
*/
void Scene::setBlenderInputFile(const std::string & blenderInputFile){
	p_blenderInputFile = blenderInputFile;
}

///Sets the blenderScene of the Scene
/**	@param blenderScene : blenderScene of the Scene
*/
void Scene::setBlenderScene(const std::string & blenderScene){
	p_blenderScene = blenderScene;
}

///Sets the firstFrame of the Scene
/**	@param firstFrame : firstFrame of the Scene
*/
void Scene::setFirstFrame(int firstFrame){
	p_firstFrame = firstFrame;
}

///Sets the lastFrame of the Scene
/**	@param lastFrame : lastFrame of the Scene
*/
void Scene::setLastFrame(int lastFrame){
	p_lastFrame = lastFrame;
}

///Sets the stepFrame of the Scene
/**	@param stepFrame : stepFrame of the Scene
*/
void Scene::setStepFrame(int stepFrame){
	p_stepFrame = stepFrame;
}

///Sets the outputRenderDirectory of the Scene
/**	@param outputRenderDirectory : outputRenderDirectory of the Scene
*/
void Scene::setOutputRenderDirectory(const std::string & outputRenderDirectory){
	p_outputRenderDirectory = outputRenderDirectory;
}

///Sets the renderEngine of the Scene
/**	@param renderEngine : renderEngine of the Scene
*/
void Scene::setRenderEngine(const std::string & renderEngine){
	p_renderEngine = renderEngine;
}

///Sets the cycleDevice of the Scene
/**	@param cycleDevice : cycleDevice of the Scene
*/
void Scene::setCycleDevice(const std::string & cycleDevice){
	p_cycleDevice = cycleDevice;
}

///Sets the outputFormat of the Scene
/**	@param outputFormat : outputFormat of the Scene
*/
void Scene::setOutputFormat(const std::string & outputFormat){
	p_outputFormat = outputFormat;
}

///Sets the extraOptions of the Scene
/**	@param extraOptions : extraOptions of the Scene
*/
void Scene::setExtraOptions(const std::string & extraOptions){
	p_extraOptions = extraOptions;
}

///Sets the containerName of the Scene
/**	@param containerName : containerName of the Scene
*/
void Scene::setContainerName(const std::string & containerName){
	p_containerName = containerName;
}

///Sets the vecGpuType of the Scene
/**	@param vecGpuType : vecGpuType of the Scene
*/
void Scene::setVecGpuType(const std::vector<std::string> & vecGpuType){
	p_vecGpuType = vecGpuType;
}

///Sets the requestMemory of the Scene
/**	@param requestMemory : requestMemory of the Scene
*/
void Scene::setRequestMemory(int requestMemory){
	p_requestMemory = requestMemory;
}

///Sets the renderProgressionStatus of the Scene
/**	@param renderProgressionStatus : renderProgressionStatus of the Scene
*/
void Scene::setRenderProgressionStatus(int renderProgressionStatus){
	p_renderProgressionStatus = renderProgressionStatus;
}

///Gets the workingDirectory of the Scene
/**	@return workingDirectory of the Scene
*/
const std::string & Scene::getWorkingDirectory() const{
	return p_workingDirectory;
}

///Gets the workingDirectory of the Scene
/**	@return workingDirectory of the Scene
*/
std::string & Scene::getWorkingDirectory(){
	return p_workingDirectory;
}

///Gets the custumScript of the Scene
/**	@return custumScript of the Scene
*/
const std::string & Scene::getCustumScript() const{
	return p_custumScript;
}

///Gets the custumScript of the Scene
/**	@return custumScript of the Scene
*/
std::string & Scene::getCustumScript(){
	return p_custumScript;
}

///Gets the name of the Scene
/**	@return name of the Scene
*/
const std::string & Scene::getName() const{
	return p_name;
}

///Gets the name of the Scene
/**	@return name of the Scene
*/
std::string & Scene::getName(){
	return p_name;
}

///Gets the blenderInputFile of the Scene
/**	@return blenderInputFile of the Scene
*/
const std::string & Scene::getBlenderInputFile() const{
	return p_blenderInputFile;
}

///Gets the blenderInputFile of the Scene
/**	@return blenderInputFile of the Scene
*/
std::string & Scene::getBlenderInputFile(){
	return p_blenderInputFile;
}

///Gets the blenderScene of the Scene
/**	@return blenderScene of the Scene
*/
const std::string & Scene::getBlenderScene() const{
	return p_blenderScene;
}

///Gets the blenderScene of the Scene
/**	@return blenderScene of the Scene
*/
std::string & Scene::getBlenderScene(){
	return p_blenderScene;
}

///Gets the firstFrame of the Scene
/**	@return firstFrame of the Scene
*/
int Scene::getFirstFrame() const{
	return p_firstFrame;
}

///Gets the firstFrame of the Scene
/**	@return firstFrame of the Scene
*/
int & Scene::getFirstFrame(){
	return p_firstFrame;
}

///Gets the lastFrame of the Scene
/**	@return lastFrame of the Scene
*/
int Scene::getLastFrame() const{
	return p_lastFrame;
}

///Gets the lastFrame of the Scene
/**	@return lastFrame of the Scene
*/
int & Scene::getLastFrame(){
	return p_lastFrame;
}

///Gets the stepFrame of the Scene
/**	@return stepFrame of the Scene
*/
int Scene::getStepFrame() const{
	return p_stepFrame;
}

///Gets the stepFrame of the Scene
/**	@return stepFrame of the Scene
*/
int & Scene::getStepFrame(){
	return p_stepFrame;
}

///Gets the outputRenderDirectory of the Scene
/**	@return outputRenderDirectory of the Scene
*/
const std::string & Scene::getOutputRenderDirectory() const{
	return p_outputRenderDirectory;
}

///Gets the outputRenderDirectory of the Scene
/**	@return outputRenderDirectory of the Scene
*/
std::string & Scene::getOutputRenderDirectory(){
	return p_outputRenderDirectory;
}

///Gets the renderEngine of the Scene
/**	@return renderEngine of the Scene
*/
const std::string & Scene::getRenderEngine() const{
	return p_renderEngine;
}

///Gets the renderEngine of the Scene
/**	@return renderEngine of the Scene
*/
std::string & Scene::getRenderEngine(){
	return p_renderEngine;
}

///Gets the cycleDevice of the Scene
/**	@return cycleDevice of the Scene
*/
const std::string & Scene::getCycleDevice() const{
	return p_cycleDevice;
}

///Gets the cycleDevice of the Scene
/**	@return cycleDevice of the Scene
*/
std::string & Scene::getCycleDevice(){
	return p_cycleDevice;
}

///Gets the outputFormat of the Scene
/**	@return outputFormat of the Scene
*/
const std::string & Scene::getOutputFormat() const{
	return p_outputFormat;
}

///Gets the outputFormat of the Scene
/**	@return outputFormat of the Scene
*/
std::string & Scene::getOutputFormat(){
	return p_outputFormat;
}

///Gets the extraOptions of the Scene
/**	@return extraOptions of the Scene
*/
const std::string & Scene::getExtraOptions() const{
	return p_extraOptions;
}

///Gets the extraOptions of the Scene
/**	@return extraOptions of the Scene
*/
std::string & Scene::getExtraOptions(){
	return p_extraOptions;
}

///Gets the containerName of the Scene
/**	@return containerName of the Scene
*/
const std::string & Scene::getContainerName() const{
	return p_containerName;
}

///Gets the containerName of the Scene
/**	@return containerName of the Scene
*/
std::string & Scene::getContainerName(){
	return p_containerName;
}

///Gets the vecGpuType of the Scene
/**	@return vecGpuType of the Scene
*/
const std::vector<std::string> & Scene::getVecGpuType() const{
	return p_vecGpuType;
}

///Gets the vecGpuType of the Scene
/**	@return vecGpuType of the Scene
*/
std::vector<std::string> & Scene::getVecGpuType(){
	return p_vecGpuType;
}

///Gets the requestMemory of the Scene
/**	@return requestMemory of the Scene
*/
int Scene::getRequestMemory() const{
	return p_requestMemory;
}

///Gets the requestMemory of the Scene
/**	@return requestMemory of the Scene
*/
int & Scene::getRequestMemory(){
	return p_requestMemory;
}

///Gets the renderProgressionStatus of the Scene
/**	@return renderProgressionStatus of the Scene
*/
int Scene::getRenderProgressionStatus() const{
	return p_renderProgressionStatus;
}

///Gets the renderProgressionStatus of the Scene
/**	@return renderProgressionStatus of the Scene
*/
int & Scene::getRenderProgressionStatus(){
	return p_renderProgressionStatus;
}

///Copy Function of class Scene
/**	@param other : Scene we want ot copy
*/
void Scene::copyScene(const Scene & other){
	p_workingDirectory = other.p_workingDirectory;
	p_custumScript = other.p_custumScript;
	p_name = other.p_name;
	p_blenderInputFile = other.p_blenderInputFile;
	p_blenderScene = other.p_blenderScene;
	p_firstFrame = other.p_firstFrame;
	p_lastFrame = other.p_lastFrame;
	p_stepFrame = other.p_stepFrame;
	p_outputRenderDirectory = other.p_outputRenderDirectory;
	p_renderEngine = other.p_renderEngine;
	p_cycleDevice = other.p_cycleDevice;
	p_outputFormat = other.p_outputFormat;
	p_extraOptions = other.p_extraOptions;
	p_containerName = other.p_containerName;
	p_vecGpuType = other.p_vecGpuType;
	p_requestMemory = other.p_requestMemory;
	p_renderProgressionStatus = other.p_renderProgressionStatus;
}

///Initialisation Function of class Scene
void Scene::initialisationScene(){
	p_workingDirectory = "";
	p_custumScript = "";
	p_name = "";
	p_blenderInputFile = "";
	p_blenderScene = "";
	p_firstFrame = 0;
	p_lastFrame = 0;
	p_stepFrame = 0;
	p_outputRenderDirectory = "";
	p_renderEngine = "";
	p_cycleDevice = "";
	p_outputFormat = "";
	p_extraOptions = "";
	p_containerName = "";
	p_requestMemory = 0;
	p_renderProgressionStatus = 0;
}

///Constructor of class RenderProject
RenderProject::RenderProject(){
	initialisationRenderProject();
}

///Copy Constructor of class RenderProject
/**	@param other : RenderProject we want ot copy
*/
RenderProject::RenderProject(const RenderProject & other){
	copyRenderProject(other);
}

///Destructor of class RenderProject
RenderProject::~RenderProject(){

}

///Operator = of class RenderProject
/**	@param other : RenderProject we want ot copy
 * 	@return copied class RenderProject
*/
RenderProject & RenderProject::operator = (const RenderProject & other){
	copyRenderProject(other);
	return *this;
}

///Sets the sourceProjectDir of the RenderProject
/**	@param sourceProjectDir : sourceProjectDir of the RenderProject
*/
void RenderProject::setSourceProjectDir(const std::string & sourceProjectDir){
	p_sourceProjectDir = sourceProjectDir;
}

///Sets the name of the RenderProject
/**	@param name : name of the RenderProject
*/
void RenderProject::setName(const std::string & name){
	p_name = name;
}

///Sets the vecSubDirectories of the RenderProject
/**	@param vecSubDirectories : vecSubDirectories of the RenderProject
*/
void RenderProject::setVecSubDirectories(const std::vector<std::string> & vecSubDirectories){
	p_vecSubDirectories = vecSubDirectories;
}

///Sets the computingCenter of the RenderProject
/**	@param computingCenter : computingCenter of the RenderProject
*/
void RenderProject::setComputingCenter(const ComputingCenter & computingCenter){
	p_computingCenter = computingCenter;
}

///Sets the mapContainer of the RenderProject
/**	@param mapContainer : mapContainer of the RenderProject
*/
void RenderProject::setMapContainer(const std::map<std::string, Container> & mapContainer){
	p_mapContainer = mapContainer;
}

///Sets the mapScene of the RenderProject
/**	@param mapScene : mapScene of the RenderProject
*/
void RenderProject::setMapScene(const std::map<std::string, Scene> & mapScene){
	p_mapScene = mapScene;
}

///Sets the sshExecutable of the RenderProject
/**	@param sshExecutable : sshExecutable of the RenderProject
*/
void RenderProject::setSshExecutable(const std::string & sshExecutable){
	p_sshExecutable = sshExecutable;
}

///Sets the scpExecutable of the RenderProject
/**	@param scpExecutable : scpExecutable of the RenderProject
*/
void RenderProject::setScpExecutable(const std::string & scpExecutable){
	p_scpExecutable = scpExecutable;
}

///Sets the condorSubmitExecutable of the RenderProject
/**	@param condorSubmitExecutable : condorSubmitExecutable of the RenderProject
*/
void RenderProject::setCondorSubmitExecutable(const std::string & condorSubmitExecutable){
	p_condorSubmitExecutable = condorSubmitExecutable;
}

///Sets the apptainerExecutable of the RenderProject
/**	@param apptainerExecutable : apptainerExecutable of the RenderProject
*/
void RenderProject::setApptainerExecutable(const std::string & apptainerExecutable){
	p_apptainerExecutable = apptainerExecutable;
}

///Sets the rsyncExecutable of the RenderProject
/**	@param rsyncExecutable : rsyncExecutable of the RenderProject
*/
void RenderProject::setRsyncExecutable(const std::string & rsyncExecutable){
	p_rsyncExecutable = rsyncExecutable;
}

///Sets the vecExecutableCheckGpu of the RenderProject
/**	@param vecExecutableCheckGpu : vecExecutableCheckGpu of the RenderProject
*/
void RenderProject::setVecExecutableCheckGpu(const std::vector<std::string> & vecExecutableCheckGpu){
	p_vecExecutableCheckGpu = vecExecutableCheckGpu;
}

///Gets the sourceProjectDir of the RenderProject
/**	@return sourceProjectDir of the RenderProject
*/
const std::string & RenderProject::getSourceProjectDir() const{
	return p_sourceProjectDir;
}

///Gets the sourceProjectDir of the RenderProject
/**	@return sourceProjectDir of the RenderProject
*/
std::string & RenderProject::getSourceProjectDir(){
	return p_sourceProjectDir;
}

///Gets the name of the RenderProject
/**	@return name of the RenderProject
*/
const std::string & RenderProject::getName() const{
	return p_name;
}

///Gets the name of the RenderProject
/**	@return name of the RenderProject
*/
std::string & RenderProject::getName(){
	return p_name;
}

///Gets the vecSubDirectories of the RenderProject
/**	@return vecSubDirectories of the RenderProject
*/
const std::vector<std::string> & RenderProject::getVecSubDirectories() const{
	return p_vecSubDirectories;
}

///Gets the vecSubDirectories of the RenderProject
/**	@return vecSubDirectories of the RenderProject
*/
std::vector<std::string> & RenderProject::getVecSubDirectories(){
	return p_vecSubDirectories;
}

///Gets the computingCenter of the RenderProject
/**	@return computingCenter of the RenderProject
*/
const ComputingCenter & RenderProject::getComputingCenter() const{
	return p_computingCenter;
}

///Gets the computingCenter of the RenderProject
/**	@return computingCenter of the RenderProject
*/
ComputingCenter & RenderProject::getComputingCenter(){
	return p_computingCenter;
}

///Gets the mapContainer of the RenderProject
/**	@return mapContainer of the RenderProject
*/
const std::map<std::string, Container> & RenderProject::getMapContainer() const{
	return p_mapContainer;
}

///Gets the mapContainer of the RenderProject
/**	@return mapContainer of the RenderProject
*/
std::map<std::string, Container> & RenderProject::getMapContainer(){
	return p_mapContainer;
}

///Gets the mapScene of the RenderProject
/**	@return mapScene of the RenderProject
*/
const std::map<std::string, Scene> & RenderProject::getMapScene() const{
	return p_mapScene;
}

///Gets the mapScene of the RenderProject
/**	@return mapScene of the RenderProject
*/
std::map<std::string, Scene> & RenderProject::getMapScene(){
	return p_mapScene;
}

///Gets the sshExecutable of the RenderProject
/**	@return sshExecutable of the RenderProject
*/
const std::string & RenderProject::getSshExecutable() const{
	return p_sshExecutable;
}

///Gets the sshExecutable of the RenderProject
/**	@return sshExecutable of the RenderProject
*/
std::string & RenderProject::getSshExecutable(){
	return p_sshExecutable;
}

///Gets the scpExecutable of the RenderProject
/**	@return scpExecutable of the RenderProject
*/
const std::string & RenderProject::getScpExecutable() const{
	return p_scpExecutable;
}

///Gets the scpExecutable of the RenderProject
/**	@return scpExecutable of the RenderProject
*/
std::string & RenderProject::getScpExecutable(){
	return p_scpExecutable;
}

///Gets the condorSubmitExecutable of the RenderProject
/**	@return condorSubmitExecutable of the RenderProject
*/
const std::string & RenderProject::getCondorSubmitExecutable() const{
	return p_condorSubmitExecutable;
}

///Gets the condorSubmitExecutable of the RenderProject
/**	@return condorSubmitExecutable of the RenderProject
*/
std::string & RenderProject::getCondorSubmitExecutable(){
	return p_condorSubmitExecutable;
}

///Gets the apptainerExecutable of the RenderProject
/**	@return apptainerExecutable of the RenderProject
*/
const std::string & RenderProject::getApptainerExecutable() const{
	return p_apptainerExecutable;
}

///Gets the apptainerExecutable of the RenderProject
/**	@return apptainerExecutable of the RenderProject
*/
std::string & RenderProject::getApptainerExecutable(){
	return p_apptainerExecutable;
}

///Gets the rsyncExecutable of the RenderProject
/**	@return rsyncExecutable of the RenderProject
*/
const std::string & RenderProject::getRsyncExecutable() const{
	return p_rsyncExecutable;
}

///Gets the rsyncExecutable of the RenderProject
/**	@return rsyncExecutable of the RenderProject
*/
std::string & RenderProject::getRsyncExecutable(){
	return p_rsyncExecutable;
}

///Gets the vecExecutableCheckGpu of the RenderProject
/**	@return vecExecutableCheckGpu of the RenderProject
*/
const std::vector<std::string> & RenderProject::getVecExecutableCheckGpu() const{
	return p_vecExecutableCheckGpu;
}

///Gets the vecExecutableCheckGpu of the RenderProject
/**	@return vecExecutableCheckGpu of the RenderProject
*/
std::vector<std::string> & RenderProject::getVecExecutableCheckGpu(){
	return p_vecExecutableCheckGpu;
}

///Copy Function of class RenderProject
/**	@param other : RenderProject we want ot copy
*/
void RenderProject::copyRenderProject(const RenderProject & other){
	p_sourceProjectDir = other.p_sourceProjectDir;
	p_name = other.p_name;
	p_vecSubDirectories = other.p_vecSubDirectories;
	p_computingCenter = other.p_computingCenter;
	p_mapContainer = other.p_mapContainer;
	p_mapScene = other.p_mapScene;
	p_sshExecutable = other.p_sshExecutable;
	p_scpExecutable = other.p_scpExecutable;
	p_condorSubmitExecutable = other.p_condorSubmitExecutable;
	p_apptainerExecutable = other.p_apptainerExecutable;
	p_rsyncExecutable = other.p_rsyncExecutable;
	p_vecExecutableCheckGpu = other.p_vecExecutableCheckGpu;
}

///Initialisation Function of class RenderProject
void RenderProject::initialisationRenderProject(){
	p_sourceProjectDir = "";
	p_name = "";
	p_sshExecutable = "";
	p_scpExecutable = "";
	p_condorSubmitExecutable = "";
	p_apptainerExecutable = "";
	p_rsyncExecutable = "";
}

///Constructor of class ProgramOption
ProgramOption::ProgramOption(){
	initialisationProgramOption();
}

///Copy Constructor of class ProgramOption
/**	@param other : ProgramOption we want ot copy
*/
ProgramOption::ProgramOption(const ProgramOption & other){
	copyProgramOption(other);
}

///Destructor of class ProgramOption
ProgramOption::~ProgramOption(){

}

///Operator = of class ProgramOption
/**	@param other : ProgramOption we want ot copy
 * 	@return copied class ProgramOption
*/
ProgramOption & ProgramOption::operator = (const ProgramOption & other){
	copyProgramOption(other);
	return *this;
}

///Sets the wantStatus of the ProgramOption
/**	@param wantStatus : wantStatus of the ProgramOption
*/
void ProgramOption::setWantStatus(bool wantStatus){
	p_wantStatus = wantStatus;
}

///Sets the vecStatusScene of the ProgramOption
/**	@param vecStatusScene : vecStatusScene of the ProgramOption
*/
void ProgramOption::setVecStatusScene(const std::vector<std::string> & vecStatusScene){
	p_vecStatusScene = vecStatusScene;
}

///Sets the wantPush of the ProgramOption
/**	@param wantPush : wantPush of the ProgramOption
*/
void ProgramOption::setWantPush(bool wantPush){
	p_wantPush = wantPush;
}

///Sets the vecPushScene of the ProgramOption
/**	@param vecPushScene : vecPushScene of the ProgramOption
*/
void ProgramOption::setVecPushScene(const std::vector<std::string> & vecPushScene){
	p_vecPushScene = vecPushScene;
}

///Sets the wantPull of the ProgramOption
/**	@param wantPull : wantPull of the ProgramOption
*/
void ProgramOption::setWantPull(bool wantPull){
	p_wantPull = wantPull;
}

///Sets the vecPullScene of the ProgramOption
/**	@param vecPullScene : vecPullScene of the ProgramOption
*/
void ProgramOption::setVecPullScene(const std::vector<std::string> & vecPullScene){
	p_vecPullScene = vecPullScene;
}

///Sets the wantList of the ProgramOption
/**	@param wantList : wantList of the ProgramOption
*/
void ProgramOption::setWantList(bool wantList){
	p_wantList = wantList;
}

///Sets the wantScript of the ProgramOption
/**	@param wantScript : wantScript of the ProgramOption
*/
void ProgramOption::setWantScript(bool wantScript){
	p_wantScript = wantScript;
}

///Sets the vecScriptScene of the ProgramOption
/**	@param vecScriptScene : vecScriptScene of the ProgramOption
*/
void ProgramOption::setVecScriptScene(const std::vector<std::string> & vecScriptScene){
	p_vecScriptScene = vecScriptScene;
}

///Gets the wantStatus of the ProgramOption
/**	@return wantStatus of the ProgramOption
*/
bool ProgramOption::getWantStatus() const{
	return p_wantStatus;
}

///Gets the wantStatus of the ProgramOption
/**	@return wantStatus of the ProgramOption
*/
bool & ProgramOption::getWantStatus(){
	return p_wantStatus;
}

///Gets the vecStatusScene of the ProgramOption
/**	@return vecStatusScene of the ProgramOption
*/
const std::vector<std::string> & ProgramOption::getVecStatusScene() const{
	return p_vecStatusScene;
}

///Gets the vecStatusScene of the ProgramOption
/**	@return vecStatusScene of the ProgramOption
*/
std::vector<std::string> & ProgramOption::getVecStatusScene(){
	return p_vecStatusScene;
}

///Gets the wantPush of the ProgramOption
/**	@return wantPush of the ProgramOption
*/
bool ProgramOption::getWantPush() const{
	return p_wantPush;
}

///Gets the wantPush of the ProgramOption
/**	@return wantPush of the ProgramOption
*/
bool & ProgramOption::getWantPush(){
	return p_wantPush;
}

///Gets the vecPushScene of the ProgramOption
/**	@return vecPushScene of the ProgramOption
*/
const std::vector<std::string> & ProgramOption::getVecPushScene() const{
	return p_vecPushScene;
}

///Gets the vecPushScene of the ProgramOption
/**	@return vecPushScene of the ProgramOption
*/
std::vector<std::string> & ProgramOption::getVecPushScene(){
	return p_vecPushScene;
}

///Gets the wantPull of the ProgramOption
/**	@return wantPull of the ProgramOption
*/
bool ProgramOption::getWantPull() const{
	return p_wantPull;
}

///Gets the wantPull of the ProgramOption
/**	@return wantPull of the ProgramOption
*/
bool & ProgramOption::getWantPull(){
	return p_wantPull;
}

///Gets the vecPullScene of the ProgramOption
/**	@return vecPullScene of the ProgramOption
*/
const std::vector<std::string> & ProgramOption::getVecPullScene() const{
	return p_vecPullScene;
}

///Gets the vecPullScene of the ProgramOption
/**	@return vecPullScene of the ProgramOption
*/
std::vector<std::string> & ProgramOption::getVecPullScene(){
	return p_vecPullScene;
}

///Gets the wantList of the ProgramOption
/**	@return wantList of the ProgramOption
*/
bool ProgramOption::getWantList() const{
	return p_wantList;
}

///Gets the wantList of the ProgramOption
/**	@return wantList of the ProgramOption
*/
bool & ProgramOption::getWantList(){
	return p_wantList;
}

///Gets the wantScript of the ProgramOption
/**	@return wantScript of the ProgramOption
*/
bool ProgramOption::getWantScript() const{
	return p_wantScript;
}

///Gets the wantScript of the ProgramOption
/**	@return wantScript of the ProgramOption
*/
bool & ProgramOption::getWantScript(){
	return p_wantScript;
}

///Gets the vecScriptScene of the ProgramOption
/**	@return vecScriptScene of the ProgramOption
*/
const std::vector<std::string> & ProgramOption::getVecScriptScene() const{
	return p_vecScriptScene;
}

///Gets the vecScriptScene of the ProgramOption
/**	@return vecScriptScene of the ProgramOption
*/
std::vector<std::string> & ProgramOption::getVecScriptScene(){
	return p_vecScriptScene;
}

///Copy Function of class ProgramOption
/**	@param other : ProgramOption we want ot copy
*/
void ProgramOption::copyProgramOption(const ProgramOption & other){
	p_wantStatus = other.p_wantStatus;
	p_vecStatusScene = other.p_vecStatusScene;
	p_wantPush = other.p_wantPush;
	p_vecPushScene = other.p_vecPushScene;
	p_wantPull = other.p_wantPull;
	p_vecPullScene = other.p_vecPullScene;
	p_wantList = other.p_wantList;
	p_wantScript = other.p_wantScript;
	p_vecScriptScene = other.p_vecScriptScene;
}

///Initialisation Function of class ProgramOption
void ProgramOption::initialisationProgramOption(){
	p_wantStatus = false;
	p_wantPush = false;
	p_wantPull = false;
	p_wantList = false;
	p_wantScript = false;
}


Generated by: GCOVR (Version 4.2)