Configuration.h

#ifndef CONFIGURATION_H
#define	CONFIGURATION_H

#include <boost/shared_ptr.hpp>

namespace DataImporter_ns
{

class Configuration
{
public:
//------------------------------------------------------------------------------
//	[Public] Shared pointer typedef
//------------------------------------------------------------------------------
	typedef boost::shared_ptr<Configuration> SP;

private:
//------------------------------------------------------------------------------
//	[Private] Constructor destructor deleter
//------------------------------------------------------------------------------
	Configuration(std::string certificateFile, std::string storagePath,
        std::string dIDBHost, unsigned int dIDBPort, std::string dIDBUser,
        std::string dIDBPassword, std::string dIDBSchema,
        std::string dIDBIndexTable, std::string dIDBRejectedTable,
        std::string remoteHost, unsigned int remotePort,
        std::string remoteUsername, std::string remotePassword,
        std::string databaseHost, unsigned int databasePort,
        std::string databaseUsername, std::string databasePassword,
        std::string databaseSchema, std::string databaseTable,
        unsigned int refreshTime, unsigned int timeout) :
        m_certificateFile (certificateFile), m_storagePath(storagePath),
        m_dIDBHost(dIDBHost), m_dIDBPort(dIDBPort), m_dIDBUser(dIDBUser),
        m_dIDBPassword(dIDBPassword), m_dIDBSchema(dIDBSchema),
        m_dIDBIndexTable(dIDBIndexTable), m_dIDBRejectedTable(dIDBRejectedTable),
        m_remoteHost(remoteHost), m_remotePort(remotePort),
        m_remoteUsername(remoteUsername), m_remotePassword(remotePassword),
        m_databaseHost(databaseHost), m_databasePort(databasePort),
        m_databaseUsername(databaseUsername), m_databasePassword(databasePassword),
        m_databaseSchema(databaseSchema), m_databaseTable(databaseTable),
        m_refreshTime(refreshTime), m_timeout(timeout) { };

	virtual ~Configuration() {}

	class Deleter;
	friend class Deleter;
	class Deleter
	{
	public:
		void operator()(Configuration* c) { delete c; }
	};

public:
//------------------------------------------------------------------------------
//	[Public] Create class method
//------------------------------------------------------------------------------
	static Configuration::SP create(std::string certificateFile,
        std::string storagePath, std::string dIDBHost, unsigned int dIDBPort,
        std::string dIDBUser, std::string dIDBPassword, std::string dIDBSchema,
        std::string dIDBIndexTable, std::string dIDBRejectedTable,
        std::string remoteHost, unsigned int remotePort,
        std::string remoteUsername, std::string remotePassword,
        std::string databaseHost, unsigned int databasePort,
        std::string databaseUsername, std::string databasePassword,
        std::string databaseSchema, std::string databaseTable,
        unsigned int refreshTime, unsigned int timeout)
	{
		Configuration::SP c_sp(new Configuration(certificateFile, storagePath,
            dIDBHost, dIDBPort, dIDBUser, dIDBPassword, dIDBSchema,
            dIDBIndexTable, dIDBRejectedTable, remoteHost, remotePort,
            remoteUsername, remotePassword, databaseHost, databasePort,
            databaseUsername, databasePassword, databaseSchema, databaseTable,
            refreshTime, timeout), Configuration::Deleter());

		return c_sp;
	}

//------------------------------------------------------------------------------
//	[Public] Getter methods
//------------------------------------------------------------------------------
	std::string	getCertificateFile() const { return m_certificateFile; }
    std::string getStoragePath() const { return m_storagePath; }
	std::string getDIDBHost() const { return m_dIDBHost; }
	unsigned int getDIDBPort() const { return m_dIDBPort; }
	std::string getDIDBUser() const { return m_dIDBUser; }
	std::string getDIDBPassword() const { return m_dIDBPassword; }
	std::string getDIDBSchema() const { return m_dIDBSchema; }
	std::string getDIDBIndexTable() const { return m_dIDBIndexTable; }
	std::string getDIDBRejectedTable() const { return m_dIDBRejectedTable; }
	std::string	getRemoteHost() const { return m_remoteHost; }
	unsigned int getRemotePort() const { return m_remotePort; }
	std::string	getRemoteUsername() const { return m_remoteUsername; }
	std::string	getRemotePassword() const { return m_remotePassword; }
	std::string	getDatabaseHost() const { return m_databaseHost; }
	unsigned int getDatabasePort() const { return m_databasePort; }
	std::string	getDatabaseUsername() const { return m_databaseUsername; }
	std::string	getDatabasePassword() const { return m_databasePassword; }
	std::string	getDatabaseSchema() const { return m_databaseSchema; }
	std::string	getDatabaseTable() const { return m_databaseTable; }
	unsigned int getRefreshTime() const { return m_refreshTime; }
	unsigned int getTimeout() const { return m_timeout; }

private:
//------------------------------------------------------------------------------
//	[Private] class variables
//------------------------------------------------------------------------------
	//Absolute path to certificate chain file
	const std::string m_certificateFile;

	//Absolute path to storage
	const std::string m_storagePath;

	//Host where data import database is running
	const std::string m_dIDBHost;

	//Port where data import database is listening
	const unsigned int m_dIDBPort;

	//User to login in data import database
	const std::string m_dIDBUser;

	//Password to login in data import database
	const std::string m_dIDBPassword;

	//Schema where data import tables are located
	const std::string m_dIDBSchema;

	//Index table name
	const std::string m_dIDBIndexTable;

	//Rejected table name
	const std::string m_dIDBRejectedTable;

    //Metadata exporter remote host
	const std::string	m_remoteHost;

    //Metadata exporter remote port
	const unsigned int m_remotePort;

    //Metadata exporter login username
	const std::string	m_remoteUsername;

    //Metadata exporter remote password
	const std::string	m_remotePassword;

    //Metadata local database host
	const std::string	m_databaseHost;

    //Metadata local database port
	const unsigned int m_databasePort;

    //Metadata local database username
	const std::string	m_databaseUsername;

    //Metadata local database password
	const std::string	m_databasePassword;

    //Metadata local database schema
	const std::string	m_databaseSchema;

    //Metadata local database table
	const std::string	m_databaseTable;

    //Remote database request period (seconds)
	const unsigned int m_refreshTime;

	//Connection timeout (seconds)
	const unsigned int m_timeout;
};

}   //End of namespace

#endif	/* CONFIGURATION_H */