// Channel.cpp
#include <string>
#include <vector>
#include <memory>
#include "Channel.h"
#include "Station.h"

namespace math1d_cl
{
	const int& Channel::getId()
	{
		return m_id;
	}

	void Channel::setId(const int& id)
	{
		m_id = id;
	}

	const std::string& Channel::getName()
	{
		return m_name;
	}
	
	void Channel::setName(const std::string& name)
	{
		m_name = name;
	}
	
	const int& Channel::getSourceStationId()
	{
		return m_sourceStationId;
	}
	
	void Channel::setSourceStationId(const int& sourceStationId)
	{
		m_sourceStationId = sourceStationId;
	}

	const int& Channel::getSourceStationIndex()
	{
		return m_sourceStationIndex;
	}
	
	void Channel::setSourceStationIndex(const int& sourceStationIndex)
	{
		m_sourceStationIndex = sourceStationIndex;
	}

	const int& Channel::getStationId()
	{
		return m_stationId;
	}
	
	void Channel::setStationId(const int& stationId)
	{
		m_stationId = stationId;
	}

	const int& Channel::getStationIndex()
	{
		return m_stationIndex;
	}
	
	void Channel::setStationIndex(const int& stationIndex)
	{
		m_stationIndex = stationIndex;
	}
	
	/*const std::shared_ptr<Station>& Channel::getStation()
	{
		return m_station;
	}
	
	void Channel::setStation(const std::shared_ptr<Station>& station)
	{
		m_station = station;
	}*/
	
	const double& Channel::getH()
	{
		return m_h;
	}
	
	void Channel::setH(const double& h)
	{
		m_h = h;
	}
	
	const double& Channel::getD()
	{
		return m_d;
	}
	
	void Channel::setD(const double& d)
	{
		m_d = d;
	}
	
	const double& Channel::getLength()
	{
		return m_length;
	}
	
	void Channel::setLength(const double& length)
	{
		m_length = length;
	}
	
	const double& Channel::getSlope()
	{
		return m_slope;
	}
	
	void Channel::setSlope(const double& slope)
	{
		m_slope = slope;
	}
	
	const double& Channel::getBankSlope()
	{
		return m_bankSlope;
	}
	
	void Channel::setBankSlope(const double& bankSlope)
	{
		m_bankSlope = bankSlope;
	}
	
	const double& Channel::getDepth()
	{
		return m_depth;
	}
	
	void Channel::setDepth(const double& depth)
	{
		m_depth = depth;
	}
	
	const double& Channel::getWidth()
	{
		return m_width;
	}
	
	void Channel::setWidth(const double& width)
	{
		m_width = width;
	}
	
	const double& Channel::getN()
	{
		return m_n;
	}
	
	void Channel::setN(const double& n)
	{
		m_n = n;
	}
	
	const int& Channel::getSubbasinId()
	{
		return m_subbasinId;
	}
	
	void Channel::setSubbasinId(const int& subbasinId)
	{
		m_subbasinId = subbasinId;
	}
	
	const int& Channel::getSubbasinIndex()
	{
		return m_subbasinIndex;
	}
	
	void Channel::setSubbasinIndex(const int& subbasinIndex)
	{
		m_subbasinIndex = subbasinIndex;
	}

	std::vector<int>& Channel::getUpstreams()
	{
		return m_upstreams;
	}
	
	void Channel::setUpstreams(const std::vector<int>& upstreams)
	{
		m_upstreams = upstreams;
	}
	
	const int& Channel::getDownstream()
	{
		return m_downstream;
	}
	
	void Channel::setDownstream(const int& downstream)
	{
		m_downstream = downstream;
	}

	Hydrograph& Channel::getHydrograph()
	{
		return m_hydrograph;
	}

	void Channel::setHydrograph(const Hydrograph& hydrograph)
	{
		m_hydrograph = hydrograph;
	}
}