#include "date.h"
#include "time.h"
#include "vector.h"
#include "weather.h"
#include<iostream>
#include <fstream>
#include<sstream>
#include <cmath>
#include<map>
#include<string>
#include "BinarySearchTree.h"
using namespace std;
string FileName = "data/met_index.txt"; // enter the file name of the file here to read the file
string OutFileName = "WindTempSolar.csv"; // enter the file name here to write to the file
void ReadAllDataFromFile(Vector<Weather> &WeatherVec,string FileName, Bst<Weather> &WeatherTree); // used to read the record from the file and store in class Vector obj
void PrintMenu(); // print the menu options
float CalAvgWindSpeed(Vector<Weather> & Vec,unsigned month, unsigned year); // calculatate the average windspeed of the month and year
float CalAvgTemp(Vector<Weather> & Vec,unsigned month, unsigned year); // calculate the average temperature of the month and year
float CalSolarRad(Vector<Weather> &WeatherVecObj, unsigned Month, unsigned Year); // calculate the solar radiation of the month and year
string GetMonthName(unsigned month); // get the string name of the month
bool CheckChoice(int &I_Choice, string S_choice); // error checking of user input of the Choice
bool CheckYear(unsigned &Year, string S_Year);// error checking of user input of the year
bool CheckMonth(unsigned &Month, string S_Month);// error checking of user input of the month
void PrintYearRequest(); // prompt for the year
void PrintMonthRequest(); // prompt for the month
void Option1(Bst<Weather> &WeatherTree,multimap<int,Weather> MonthMap); //do the task of option 1
void Option2(Bst<Weather> &WeatherTree); // do the task of option 2
void Option3(Bst<Weather> &WeatherTree); // do the task of option 3
void Option4(Bst<Weather> &WeatherTree); // do the task of option 4
void PrintOption1Output(unsigned Month,unsigned Year,float AverageTemperature,float AverageWindSpeed); // print option 1 to screen
void PrintOption2OutPut(unsigned Month, float AverageTemperature, float AverageWindSpeed); // print option 2 output to screen
void PrintOption3Output(unsigned Month,float Solar_Kwh_Msqr); // print option 3 output to screen
void PrintOption4ToCsv(unsigned Month,float Solar_Kwh_Msqr,float AvgWindSpeed,float AvgTemperature,unsigned Year,ofstream &Outfile); // print option 4 to screen
int main ()
{
//----------------------------Initialising and declaration of variable--------------------------
int Choice=0;
string S_Choice ="",IgnoreLine="",InsertIntoBst;
//-----------------------------------------------------------------------------------------------
Vector<Weather> WeatherVec; // create a Vector object of type Weather and name it WeatherVec
Bst<Weather> WeatherTree;
multimap<int,Weather> MonthMap;
ifstream infile; // instantiate ifstream to read file
infile.open(FileName); // open file through ifstream
if(infile.is_open())
{
// check if the file is open
ReadAllDataFromFile(WeatherVec,FileName,WeatherTree); // call the function to store all the record in Vector obj
infile.close(); // close the file
PrintMenu(); // print the menu options
cout<<"Please enter your choice"<<endl; // prompt for S_Choice
cin>>S_Choice;//Get S_Choice
while(CheckChoice(Choice,S_Choice)==false)
{
// if incorrect user input prompt and get again
cout<<"Please enter your choice again 1 - 5"<<endl;
cin>>S_Choice;
}
cout<<endl; // print new line
while (Choice!=5) // if the choice inputed by the user not equal 5 enter while loop
{
switch(Choice)
{
// check the choice value
case 1:
Option1(WeatherTree,MonthMap); // call option 1 functions
break;
case 2:
Option2(WeatherTree); // call option 2 functions
break;
case 3:
Option3(WeatherTree); // call option 3 functions
break;
case 4:
Option4(WeatherTree); // call option 4 functions
break;
}
cout<<endl;
PrintMenu(); // print the menu option again
cout<<"Please enter your choice again"<<endl; // prompt for the S_choice
cin>>S_Choice; // get S_Choice
cout<<endl;
while(CheckChoice(Choice,S_Choice)==false)
{
// if user input incorrect prompt and get S_Choice again
cout<<"Please enter your choice again 1 - 5 "<<endl;
cin>>S_Choice;
}
if(Choice==5)
{
// if the user input is = 5 break from the loop
break;
}
}
}
else
{
// if file is not opened print error
cout<<"Error reading file"<<endl;
}
// print to screen program ended
cout<<"Program ended"<<endl;
return 0; // return to os
}
void PrintMenu()
{
// printing out the menu option titles
cout<<endl;
cout<<"1. Print the average wind speed and average ambient air temperature for a specified month and year to screen."<<endl;
cout<<endl;
cout<<"2. Print the Average wind speed and average ambient air temperature for each month of a specified year. "<<endl;
cout<<endl;
cout<<"3. Print the Total solar radiation in kWh/m2 for each month of a specified year. "<<endl;
cout<<endl;
cout<<"4. Write the Average wind speed (km/h), average ambient air temperature and total solar radiation in \n"
<<" kWh/m2 for each month of a specified year to file. "<<endl;
cout<<endl;
cout<<"5. Exit the program. "<<endl;
cout<<endl;
}
void PrintYearRequest()
{
cout<<"Please Enter the Year (Not earlier than 1998 and not later than 2020)"<<endl;
cout<<endl;
}
void PrintMonthRequest()
{
cout<<"Please Enter the Month (Between 1 to 12) "<<endl;
cout<<endl;
}
float CalAvgWindSpeed(Vector<Weather> & WeatherVecObj,unsigned month, unsigned year)
{
// calculating average windspeed for the months of the year
float AverageWindSpeed=0.0,ConvertingSpeed=0.0;
unsigned I_Month=0,counter=0;
for(int i = 0; i<WeatherVecObj.GetLength(); i++) // loop till the last element of the vector
{
istringstream(WeatherVecObj[i].GetDate().GetMonth())>>I_Month; // convert string month to unsigned U_Month
if(WeatherVecObj[i].GetDate().GetYear()== year && I_Month==month) // if the element year and the month is the same as the specific year and month go in if statement
{
ConvertingSpeed = WeatherVecObj[i].GetSpeed()*3.6; // the windspeed of the element times 3.6 and assigned to Converting Speed
AverageWindSpeed += ConvertingSpeed; // AverageWindSpeed plus adding ConvertingSpeed in the loop
counter++; // increment counter by 1
}
}
if(AverageWindSpeed!=0)
{
// if avaerage wind speed not equals to 0
AverageWindSpeed = AverageWindSpeed/counter; //AverageWindSpeed is divided by counter
AverageWindSpeed = round(AverageWindSpeed*10)/10; // round up to the first decimal point
}
return AverageWindSpeed;// return the average wind speed of the month of the year
}
float CalSolarRad(Vector<Weather> &WeatherVecObj, unsigned Month, unsigned Year)
{
// calculate solar radiation
float Total_Solar_Rad_kWh_Msqr=0.0,Get_Solar_Rad_W_Msqr=0.0,Cal_Solar_Rad_W_Msqr=0.0;
unsigned I_Month=0;
for(int i = 0; i<WeatherVecObj.GetLength(); i++) // loop till the end of the Vector
{
istringstream(WeatherVecObj[i].GetDate().GetMonth())>>I_Month;// converting string month to unsigned I_Month
if(WeatherVecObj[i].GetDate().GetYear() == Year && I_Month==Month && WeatherVecObj[i].GetSolarMSqr()>=100)
{
// if year and month = to specific year AND solar radiation value of the element is more or equal to 100 enter if statement
Get_Solar_Rad_W_Msqr = WeatherVecObj[i].GetSolarMSqr();// retrieve solar radiation of the element
Cal_Solar_Rad_W_Msqr = Get_Solar_Rad_W_Msqr*1/6; // converting the solar radiation
Cal_Solar_Rad_W_Msqr = Cal_Solar_Rad_W_Msqr/1000; // calculating the solar radiation
Total_Solar_Rad_kWh_Msqr += Cal_Solar_Rad_W_Msqr; // plus adding the solar radiation to Total_Solar_Rad_kWh_Msqr
}
}
Total_Solar_Rad_kWh_Msqr = round(Total_Solar_Rad_kWh_Msqr*10)/10; // round up the total solar radiation of the month of the year to first decimal place
return Total_Solar_Rad_kWh_Msqr; // return the total solar radiation
}
float CalAvgTemp(Vector<Weather> & WeatherVecObj,unsigned month, unsigned year)
{
float ConvertingTemp=0.0,AverageTemperature=0.0;
unsigned I_Month,counter=0;
for(int i = 0; i<WeatherVecObj.GetLength(); i++)
{
istringstream(WeatherVecObj[i].GetDate().GetMonth())>>I_Month; // converting string month to unsigned I_Month
if(WeatherVecObj[i].GetDate().GetYear() == year && I_Month==month)
{
// if year and month = to specific year AND Month
ConvertingTemp += WeatherVecObj[i].GetTemperature(); // adding to the ConvertingTemp of the temperature of each of the element
counter++; // increment counter by 1 every loop
}
}
if(ConvertingTemp!=0)
{
// if ConvertingTemp not equals to 0
AverageTemperature = ConvertingTemp/counter; // ConvertingTemp divided by counter to get average
AverageTemperature = round(AverageTemperature*10)/10; // round up to the nearing tenth
}
return AverageTemperature;
}
string GetMonthName(unsigned month)
{
// return the string name of the month entered in the parameter
string Month = "";
if(month == 1)
{
Month = "January";
return Month;
}
else if (month == 2)
{
Month = "February";
return Month;
}
else if (month == 3)
{
Month = "March";
return Month;
}
else if (month == 4)
{
Month = "April";
return Month;
}
else if (month == 5)
{
Month = "May";
return Month;
}
else if (month == 6)
{
Month = "June";
return Month;
}
else if (month == 7)
{
Month = "July";
return Month;
}
else if (month == 8)
{
Month = "August";
return Month;
}
else if (month == 9)
{
Month = "September";
return Month;
}
else if (month == 10)
{
Month = "October";
return Month;
}
else if (month == 11)
{
Month = "November";
return Month;
}
else if (month == 12)
{
Month = "December";
return Month;
}
return Month;
}
bool CheckMonth(unsigned &Month, string S_Month)
{
// method to error check the month input
unsigned U_Month;
istringstream(S_Month)>> U_Month; // convert string month to unsigned U_Month
if(U_Month>0 && U_Month<13)
{
// if U_Month is more than 0 and less than 13 set Month and return true
Month = U_Month;
return true;
}
else
{
// else return false
return false;
}
}
bool CheckYear(unsigned &Year, string S_Year)
{
// method to error check the year input
unsigned U_Year;
istringstream(S_Year)>>U_Year; // convert string month to unsigned U_Year
if(U_Year>=1998 && U_Year<2021)
{
// if U_Year is more than 1000 and less than 2021 set Year and return true
Year = U_Year; //
return true;
}
else
{
// if condition not met return false
return false;
}
}
void Option1(Bst<Weather> &WeatherTree,multimap<int,Weather> MonthMap)
{
// if Choice = 1
unsigned C_Year=0,C_Month=0,Temp_Month=0;
float AvgWindSpeed=0,AvgTemperature=0;
string S_Month ="", S_Year="";
Vector<Weather> YearVec;
Weather TempObj;
Vector<Weather> MonthVec;
PrintMonthRequest(); // prompt S_Month
cin>>S_Month; //get S_Month
while (CheckMonth(C_Month, S_Month)==false)
{
// if the C_Month is incorrect enter prompt and get again
PrintMonthRequest();
cin>>S_Month;
}
PrintYearRequest(); // prompt for S_Year
cin>>S_Year; // get S_Year
while (CheckYear(C_Year,S_Year)==false)
{
// if the C_Year is incorrect enter prompt and get again
PrintYearRequest();
cin>>S_Year;
}
if(WeatherTree.Search(C_Year)) // check if the key exist in the bst
{
YearVec = WeatherTree.ReturnVec(C_Year); // if the key exist return the Vector of the Key
{
for(int i = 0; i<YearVec.GetLength(); i++) // loop through the vector
{
istringstream(YearVec[i].GetDate().GetMonth())>>Temp_Month; // convert the string to unsigned
if(Temp_Month == C_Month)
{
TempObj = YearVec[i]; // if the weather obj in the element is = to c_Month then assign to TempObj
MonthMap.insert(pair<int,Weather>(C_Month,TempObj)); //Pair the Month together with the tempObj in multimap
}
}
}
for(auto elem: MonthMap) // for each element in MonthMap
{
MonthVec.PushBack(elem.second); // Insert the value into MonthVec
}
AvgWindSpeed= CalAvgWindSpeed(MonthVec,C_Month, C_Year); // calculate average windspeed
AvgTemperature= CalAvgTemp(MonthVec,C_Month,C_Year); // calculate average temperature
}
else
{
cout<<"No Data"<<endl;
}
PrintOption1Output(C_Month,C_Year,AvgTemperature,AvgWindSpeed); // print the output to screen*/
}
void PrintOption1Output(unsigned Month,unsigned Year,float AverageTemperature,float AverageWindSpeed)
{
// print output option
if(AverageTemperature==0 && AverageWindSpeed==0)
{
// check if windspeed and temperature is 0
cout<< GetMonthName(Month)<<" "<<Year<<" : No data"<<endl;
}
else
{
cout<< GetMonthName(Month)<<" "<<Year<<" : "; // print the month name and the year followed by windspeed and temperature
cout<<AverageWindSpeed<<" km/h, "<< AverageTemperature<<" degrees C"<<'\n';
cout<<endl;
}
}
void Option2(Bst<Weather> &WeatherTree)
{
unsigned C_Year=0;
float AvgWindSpeed=0,AvgTemperature=0;
string S_Year="";
Vector<Weather> YearVec;
PrintYearRequest();// prompt for S_Year
cin>>S_Year;// get S_Year
while (CheckYear(C_Year,S_Year)==false)
{
// if the C_Year is incorrect enter prompt and get again
PrintYearRequest();
cin>>S_Year;
}
if(WeatherTree.Search(C_Year)) // check if the key exist in the bst
{
YearVec = WeatherTree.ReturnVec(C_Year); // if the key exist return the Vector of the Key
for (unsigned i = 0; i<12; i++) // loop 12 times
{
AvgWindSpeed = CalAvgWindSpeed(YearVec,i+1, C_Year); // calculate the average windspeed of each month
AvgTemperature = CalAvgTemp(YearVec,i+1, C_Year); // caclualte the average temperature of each month
PrintOption2OutPut(i+1,AvgTemperature,AvgWindSpeed); // print the out put for each month
}
}
else
{// if key not found print No Data.
cout<<"No Data"<<endl;
}
}
void PrintOption2OutPut(unsigned Month, float AverageTemperature, float AverageWindSpeed)
{
if(AverageTemperature!=0 && AverageWindSpeed!=0)
{
// print out if temperature and windspeed is not equal to 0
cout<< GetMonthName(Month)<<" : "; // print the month name and the year followed by windspeed and temperature
cout<<AverageWindSpeed<<" km/h, "<< AverageTemperature<<" degrees C"<<'\n';
cout<<endl;
}
else
{
// else print out no data for the month
cout<< GetMonthName(Month)<<" : No data"<<endl;
cout<<endl;
}
}
void Option3(Bst<Weather> &WeatherTree)
{
unsigned C_Year=0;
float Solar_Kwh_Msqr=0;
string S_Year="";
Vector<Weather> YearVec;
PrintYearRequest();// prompt for S_Year
cin>>S_Year;// get S_Year
while (CheckYear(C_Year,S_Year)==false)
{
// if the C_Year is incorrect enter prompt and get again
PrintYearRequest();
cin>>S_Year;
}
if(WeatherTree.Search(C_Year))// check if the key exist in the bst
{
YearVec = WeatherTree.ReturnVec(C_Year); // if the key exist return the Vector of the Key
for(unsigned i = 0; i<12; i++)
{
// loop 12 times
Solar_Kwh_Msqr = CalSolarRad(YearVec, i+1, C_Year); // calculate the solar radiation kwh/m2 for each month of the year
PrintOption3Output(i+1,Solar_Kwh_Msqr); // print the output of option 3
}
}
else
{// if key not found print No Data.
cout<<"No Data"<<endl;
}
}
void PrintOption3Output(unsigned Month,float Solar_Kwh_Msqr)
{
if(Solar_Kwh_Msqr!=0)
{
// if the solar radiation is not equals to 0 print out the solar radiation in kWh/m2
cout<<GetMonthName(Month)<<": "<<Solar_Kwh_Msqr<<" kWh/m2"<<endl;
cout<<endl;
}
else
{
// print out the no data for the month
cout<<GetMonthName(Month)<<": No Data"<<endl;
cout<<endl;
}
}
void Option4(Bst<Weather> &WeatherTree)
{
unsigned C_Year=0;
float AvgWindSpeed=0,AvgTemperature=0, Solar_Kwh_Msqr=0;
string S_Year="";
Vector<Weather> YearVec;
ofstream Outfile; // instantiate the ofstream object to write file
Outfile.open(OutFileName); // open WindTempSolar.csv if not found create one
PrintYearRequest();// prompt for S_Year
cin>>S_Year;// get S_Year
while (CheckYear(C_Year,S_Year)==false)
{
// if the C_Year is incorrect enter prompt and get again
PrintYearRequest();
cin>>S_Year;
}
Outfile<<C_Year<<endl; // write the year to file
if(WeatherTree.Search(C_Year)) // check if the key exist in the bst
{
YearVec = WeatherTree.ReturnVec(C_Year); // if the key exist return the Vector of the Key
for( int i = 0; i<12; i++)
{
Solar_Kwh_Msqr = CalSolarRad(YearVec, i+1, C_Year);// calculate the solar radiation kwh/m2 for each month of the year
AvgTemperature = CalAvgTemp(YearVec,i+1,C_Year);// caclualte the average temperature of each month
AvgWindSpeed = CalAvgWindSpeed(YearVec,i+1, C_Year);// calculate the average windspeed of each month
PrintOption4ToCsv(i+1,Solar_Kwh_Msqr,AvgWindSpeed,AvgTemperature,C_Year,Outfile); // write the records of each month of the year to the file
}
}
else // if key not found print No Data.
{
Outfile<<"No Data"<<endl;
}
cout<<"Successfully wrote to "<<OutFileName<<" file"<<endl; // print to screen to indicate wrote successfully
Outfile.close(); // close the ofstream
}
void PrintOption4ToCsv(unsigned Month,float Solar_Kwh_Msqr,float AvgWindSpeed,float AvgTemperature,unsigned Year,ofstream &Outfile)
{
if(Solar_Kwh_Msqr!=0 &&AvgWindSpeed!=0 && AvgTemperature!=0)
{
Outfile<<GetMonthName(Month)<<','<<AvgWindSpeed<<','<<AvgTemperature<<','<<Solar_Kwh_Msqr<<endl;
cout<<endl;
}
else
{
Outfile<<GetMonthName(Month)<<','<<"No Data"<<endl;
cout<<endl;
}
}
void ReadAllDataFromFile(Vector<Weather> &WeatherVec,string FileName,Bst<Weather> &WeatherTree)
{
//----------------------------------Variable and objects declaration and initialisation-----------------------------------
string IgnoreColumn,T_speed,getLine,T_Temperature="",S_Day,S_Month,S_Year,S_Hrs,S_Mins,IgnoreLine,S_Solar_M_Sqr,FileNames;
unsigned Temp_Day=0,Temp_Year=0;
float I_Speed=0,F_Temperature=0,F_Solar_M_Sqr=0;
int Temp_Hrs=0,Temp_Mins=0,ErrorFile = 0,LoadedFile =0;
Date T_DateObj;
Time T_TimeObj;
Weather T_WObj;
//----------------------------------------------------------------------------------------------------------------------------
ifstream infile(FileName);
cout<<"Loading Files";
while(!infile.eof())
{
cout<<".";
getline(infile,FileNames);
// loop till the end of file
FileNames="data/"+FileNames;
ifstream infiles (FileNames);
if (infiles.is_open())
{
cout<<".";
getline(infiles,IgnoreLine,'\n'); // read in the file line of the file which contains the titles
while(!infiles.eof())
{
getline(infiles,S_Day,'/');// read data till the delimiter /
istringstream(S_Day)>>Temp_Day; // convert string day to unsigned day
getline(infiles,S_Month,'/');// read data till the delimiter /
getline(infiles,S_Year,' ');// read data till the delimiter ' '
istringstream (S_Year)>>Temp_Year;// convert string year to unsigned year
getline(infiles,S_Hrs,':');// read data till the delimiter :
istringstream(S_Hrs)>>Temp_Hrs;// convert string hours to int hours
getline(infiles,S_Mins,',');// read data till the delimiter ,
istringstream(S_Mins)>>Temp_Mins;// convert string minutes to int minutes
T_DateObj.SetDay(Temp_Day);//Set the day to date object T_DateObj
T_DateObj.SetMonth(S_Month);// set the month to date object T_DateObj
T_DateObj.SetYear(Temp_Year); // set the year to date object T_DateObj
T_TimeObj.SetHours(Temp_Hrs); // set the hours to time object T_TimeObj
T_TimeObj.SetMins(Temp_Mins); // set the minutes to time object T_TimeObj
T_WObj.SetDate(T_DateObj); //set the date T_WObj weather object
T_WObj.SetTime(T_TimeObj); // set the time T_WObj weather object
for(int i =0; i<9; i++)
{
// loop 9 times to ignore 9 columns
getline(infiles,IgnoreColumn,',');
}
getline(infiles,T_speed,','); // read data till the delimiter ,
istringstream(T_speed)>>I_Speed; // convert string windspeed to float windspeed
T_WObj.SetSpeed(I_Speed);
getline(infiles,S_Solar_M_Sqr,',');// read data till the delimiter ,
istringstream(S_Solar_M_Sqr)>>F_Solar_M_Sqr; // convert string solar radiation to float solar radiation
T_WObj.SetSolarMSqr(F_Solar_M_Sqr); // set the solar radiation to T_WObj weather object
for(int i =0; i<5; i++)
{
// loop 5 times to ignore 5 columns
getline(infiles,IgnoreColumn,',');// read data till the delimiter ,
}
getline(infiles,T_Temperature,'\n');// read data till the delimiter \n
if(!T_Temperature.empty()) // check if the temperature string is not empty
{
istringstream(T_Temperature)>>F_Temperature; // convert the string temperature to float temperature
T_WObj.SetTemperature(F_Temperature); // set temperature to T_WObj weather object
WeatherTree.Insert(Temp_Year,T_WObj); // insert the object into Bst Vector according to the Key(Temp_Year)
}
T_Temperature = ""; // erase the value of temperature
}
LoadedFile++; // count the successfully opened files
}
else
{
cout<<endl;
cout<<"Failed to open: "<<FileNames<<endl; // print the failed to open file name to screen
cout<<"Loading Files";
ErrorFile++; // count the files that failed to open
}
}
cout<<endl;
cout<<"Loading Completed"<<endl;
cout<<"Total files loaded: "<<LoadedFile<<" "<<"Number of files not loaded: "<<ErrorFile<<" "<<endl;
}
bool CheckChoice(int &I_Choice,string S_choice)
{
// error checking the choice user input
int T_Choice; //
istringstream(S_choice)>>T_Choice;// convert string choice to int choice
if(T_Choice>0 && T_Choice <6)
{
// int choice is more than 0 AND less than 5
I_Choice = T_Choice; // set I_Choice to int T_Choice
return true;// return true
}
else
{
//if condition not met return false
return false;
}
}
#include "date.h"
Date::Date()
{
m_day = 0; // initialise the m_day
m_month="Invalid Month";// initialise the m_month
m_year = 0; // initialise m_year
}
Date::~Date()
{
m_day = 0; // overwrite the m_day
m_month="Invalid Month";// overwrite the m_month
m_year = 0; // overwrite the m_year
}
bool Date::SetDay(unsigned day )
{
if(day > 0 && day <= 31)
{ // if day is more than 0 and less or equal to 31
m_day = day; // set m_day to day
return true; // return true
}
else
{ // condition not met return false
return false;
}
}
unsigned Date::GetDay() const
{ // return value of m_day
return m_day;
}
bool Date::SetMonth(string month)
{
unsigned U_Month;
istringstream(month)>>U_Month; // convert string month to unsigned U_Month
if(U_Month>0 && U_Month<13)
{ // if I_Month more than 0 and less than 13
m_month=month; // set m_month = month
return true;
}
else
{ // if condition not met return false
return false;
}
}
string Date::GetMonth() const
{
return m_month; // return the value of month of the class
}
bool Date::SetYear(unsigned year)
{
if(year>1998 && year<=2020)
{ // if year more than 1000 AND year less or equal to 2020
m_year = year; // set m_year = year and return true
return true;
}
else
{// if condition not met return false
return false;
}
}
unsigned Date:: GetYear() const
{ //return the year of the class
return m_year;
}
#include "time.h"
Time::Time()
{ // inititalise the members of the class
m_Hours = 0;
m_Mins = 0;
}
Time::~Time()
{ // erase or overwrite the value of instantiated Time class
m_Hours = 0;
m_Mins = 0;
}
bool Time::SetHours(int Hours)
{ // set Hours equals to m_Hours if Hour is more or equal to zero AND less than 24
if(Hours >=0 && Hours<24)
{
m_Hours = Hours;
return true;
}
else
{// if condition not met then return false
return false;
}
}
bool Time::SetMins(int minutes)
{ // if minutes more to equal to zero AND minutes less than 60
if (minutes >=0 && minutes <60)
{// set member m_Mins to minutes
m_Mins = minutes;
return true;
}
else
{// return false if condition not met
return false;
}
}
int Time::GetHours() const
{ // return the value of hours of the class
return m_Hours;
}
int Time::GetMins() const
{// return the value of minutes of the class
return m_Mins;
}
#include "weather.h"
Weather::Weather()
{// initialise the value of members
m_Speed = 0;
m_Temperature = 0;
m_Solar_M_Sqr = 0;
}
Weather::~Weather()
{ //// erase the value or overwritting the value of members
m_Speed = 0;
m_Temperature = 0;
m_Solar_M_Sqr = 0;
}
bool Weather:: SetSpeed( float T_Speed)
{ // check if T_Speed is more or equal to 0
if(T_Speed >=0 )
{ // if yes set member speed to T_speed
m_Speed = T_Speed;
return true;
}
else
{// if not return false
return false;
}
}
void Weather:: SetTemperature( float T_Temperature)
{
// set m_Temperature to T_Temperature
m_Temperature = T_Temperature;
}
void Weather::SetDate(Date T_DateObj)
{ // set m_DateObj = Date T_DateObj
m_DateObj = T_DateObj;
}
void Weather::SetTime(Time T_TimeObj)
{
m_TimeObj = T_TimeObj;
} // set m_TimeObj to T_TimeObj
float Weather::GetSpeed() const
{// return the value of windspeed of the class
return m_Speed;
}
float Weather::GetTemperature() const
{
return m_Temperature;
}
void Weather::SetSolarMSqr(float SolarMSqr)
{ // set m_Solar_M_Sqr = SolarMSqr
m_Solar_M_Sqr = SolarMSqr;
}
float Weather::GetSolarMSqr()
{ // return the value of m_Solar_M_Sqr
return m_Solar_M_Sqr;
}
Date Weather::GetDate() const
{ // return the of the Date of the class
return m_DateObj;
}
Time Weather::GetTime() const
{ // return the m_TimeObj value
return m_TimeObj;
}
#ifndef VECTOR_H
#define VECTOR_H
#include <iostream>
#define DefaultSize 10
//---------------------------------------------------------------
/**
*@class Vector
*@brief The Vector template that holds the inputted data
*
*
*The Vector Template can be created in with any data type
*it is used to hold the inputted data from the file
*and store it.
*
*
*
*
*@author Tan Jun Qi
*@version 10
*@date 19/June/2020 Singapore,Singapore
*
*
*
*/
//---------------------------------------------------------------------------
using namespace std;
template<class T>
class Vector
{
public:
/**
*@brief The Default Vector constructor
*
*This initialise the member or attributes of time class and
*allocate memory space in the heap memory for the dynamic array
*
*
*@return void
*
*/
Vector();
/**
*
*@fn GetSize()
*
*@brief Function to return the total size of the array
*
*
*return the total size of the array to check if the array
*is expanding
*
*
*@return int
*
*/
int GetSize() const ;
/**
*
*@fn IsEmpty()
*
*@brief Function to check if the array is empty
*
*
*check if there are any elements inside of the array
*return false if there is elements return true if its
*empty
*
*@return bool
*
*/
bool IsEmpty();
/**
*
*@fn PushBack(T value)
*
*@brief Function to add in new data into array
*
*
*Add the data into the last element of the array
*
*
*
*@return void
*
*/
void PushBack(T value);
/**
*
*@fn PopBack()
*
*@brief Erase the last element of the array
*
*
*Dis count the last element of the array and enable
*it to be overwritten by new data
*
*return true if there is element in array and discounted
*
*return false if there is no element in the array
*
*@pre The array must have elements inside
*@return bool
*
*/
bool PopBack();
/**
*
*@fn Resize()
*
*@brief Resize the total size of the array
*
*
*Expand the array if the element in the array is more
*than half of the total size by 1.5 times
*
*
*@return void
*
*/
void Resize();
/**
*
*@fn GetLength()
*
*@brief Resize the length of the array
*
*
*return the total number of elements residing inside
*of the array.
*
*@return int
*
*/
int GetLength() const;
/**
*
*@overload T& operator[](int index) const
*
*@brief Overloading of [] operator
*
*overload the [] to return the element of the array
*passed in to the paramemter
*
*@param index - int type
*@return T&
*
*/
T& operator[](int index) const;
/**
*
*@fn Vector();
*
*@brief The destructor of Vector
*
*Release the memory back to the OS and set the
*memory location of the array to null.
*
*
*@return void
*
*/
~Vector();
/**
*
*@overload operator = (const Vector<T> &Vec)
*
*@brief The = operator overloader
*
*Calls the copy function and return this object.
*
*
*@param Vec - Vector of type class.
*@return Vector<T>&
*
*/
Vector<T>& operator = (const Vector<T> &Vec);
/**
*
*
*@brief The copy constructor
*
*Calls the copy function
*
*
*@param Vec - Vector of type class.
*
*/
Vector(const Vector<T>& Vec);
private:
/// Holds the number of element in the array
int m_length;
/// The dynamic array that holds the records
T *m_array;
/// Hold the total size of the array
int m_Tsize;
/**
*
*@fn Copy(const Vector<T> & Vec)
*
*@brief The copy function
*
*The function copies the data in the elements in other Vector
*to this Vector object (Deep copying)
*
*
*@param Vec - Vector of type class.
*@return bool
*
*/
bool Copy(const Vector<T> & Vec);
};
template<class T>
Vector<T>::Vector()
{
// initiate member variables to
m_length = 0;
m_array = new T[DefaultSize]; // allocate new memory location on heaps for the dynamic array
m_Tsize = DefaultSize;
}
template<class T>
Vector<T>::Vector(const Vector<T>& Vec) // copy constructor
{
Copy(Vec); // calls the copy function
}
template<class T>
bool Vector<T>::Copy(const Vector<T> & Vec) // copy function
{
if(Vec.m_array!=nullptr && Vec.GetLength()!=0 && Vec.GetSize()!=0)
{ // if other Vec m_array!=null and vec not empty and size not zero
m_length = Vec.GetLength(); // assigning Other vect's data to this object members
m_Tsize = Vec.GetSize();
m_array = new T[Vec.GetSize()]; // allocating new memory spaces for m_array
for(int i = 0; i<Vec.GetLength(); i++)
{
m_array[i] = Vec.m_array[i]; // assigning other Vector array elements to this object
}
return true;
}
else
{
return false;
}
}
template<class T>
Vector<T>& Vector<T>::operator = (const Vector<T> &Vec)
{
Copy(Vec); // calls the copy function
return *this; // return this object
}
template<class T>
Vector<T>::~Vector()
{
// release the memory location on heap back to os if dynamic array is not null
if(m_array!=nullptr)
{
delete[] m_array;
m_array = nullptr;
}
m_Tsize = 0;
m_length = 0;
}
template<class T>
int Vector<T>::GetLength() const
{
// return the length of the array
return m_length;
}
template<class T>
int Vector<T>::GetSize() const
{
// return the total size of the array
return m_Tsize;
}
template<class T>
void Vector<T>::Resize()
{
// resize the array by 1.5 times its original size
m_Tsize = m_Tsize*1.5;
T *newarray = new T[m_Tsize]; // open new dyanmic array pointer
for (int i = 0; i<m_length; i++)
{
// allocate old elements in array to new array
newarray[i] = m_array[i];
}
delete [] m_array; // delete old array
m_array = nullptr; // set old array to null
m_array = newarray; // allocate the memory location of new array to m_array
}
template<class T>
bool Vector<T>::IsEmpty()
{
// return true if there is not element in the array
if (m_length == 0)
{
return true;
}
else
{
return false;
}
}
template<class T>
void Vector<T>::PushBack(T value)
{
// add elements to the back of the array
m_array[m_length] = value;
m_length ++; // if the array element is more than half full
if(m_length>m_Tsize/2)
{
// call Resize function to resize the array
Resize();
}
}
template<class T>
bool Vector<T>::PopBack()
{
// if there is element in the array, minus the length of the array by 1
if(m_length!=0)
{
// the last element then is available to be overwritten or not in used
m_array[m_length] = 0;
m_length--;
return true;
}
else
{
// if the length if empty return false
return false;
}
}
template<class T>
T& Vector<T>::operator[](int index) const
{
// return the array element when [] is called
return m_array[index];
}
#endif // VECTOR_H
#include <iostream>
#include "Vector.h"
//---------------------------------------------------------------
/**
*@class Bst
*@brief The Sorting of the data through the use of Key
*
*
*
*Used the key to distinguish with Data should be under which node,
*then the data enters into the Vector of that node. The key will not have any
*duplicates
*
*
*
*
*@author Tan Jun Qi
*@version 4
*@date 22/July/2020 Singapore,Singapore
*
*
*
*/
//---------------------------------------------------------------------------
using namespace std;
/**
*@brief Node Struct
*
*This struct contains Key for identification, Vector for storing of datas,
*left and right points. This struct is used to create the structure of the
*Binary search tree, nodes with the key less than the root's key will be
*placed on the left and if more than root's key will be placed on the right.
*/
template <class T>
struct Node // answer why struct encapsulation is used - rationale
{
/// Used to identify the struct
int Key;
/// Used to store datas with the same key
Vector <T> YearsData;
/// left pointer
Node <T> *Left;
/// right pointer
Node <T> *Right;
};
template <class T>
class Bst
{
public:
/**
*@brief The Default constructor
*
*This constructor points the m_Root member to nullptr
*
*
*
*/
Bst();
/**
*@brief The Destructor
*
*This Destructor called the "void Delete(Node<T> *CurrentNode)"
*functions to delete all the nodes in the tree.
*
*
*
*/
~Bst();
/**
*
*@fn typedef void (*InOrderTraversalPtr)(const T&)
*
*@brief Declaration of function pointers with the signature
*
*This function pointers take in another function with the same signature to
*perform the operation/task of that function.
*
*
*
*@param T& - Template data type
*@return void
*
*/
typedef void (*InOrderTraversalPtr)(const T&);
/**
*
*@fn typedef void (*PreOrderTraversalPtr)(const T&)
*
*@brief Declaration of function pointers with the signature
*
*This function pointers take in another function with the same signature to
*perform the operation/task of that function.
*
*
*
*@param T& - Template data type
*@return void
*
*/
typedef void (*PreOrderTraversalPtr)(const T&);
/**
*
*@fn typedef void (*PostOrderTraversalPtr)(const T&)
*
*@brief Declaration of function pointers with the signature
*
*This function pointers take in another function with the same signature to
*perform the operation/task of that function.
*
*
*
*@param T& - Template data type
*@return void
*
*/
typedef void (*PostOrderTraversalPtr)(const T&);
/**
*
*@fn Search(int Key) const
*
*@brief The Searching of the Key
*
*
*This function performs the task of searching through the tree
*by its Key, if the key is found in the tree returns true else
*returns false.
*
*
*@param Key - int data type
*@return bool
*
*/
bool Search(int Key) const;
/**
*
*@fn Insert(int Key,T DataObj)
*
*@brief Inserting of data with the Key and Data
*
*This function takes in two parameter, one which is the key and
*another one which is the data. It will search through the tree if
*the key exist or not. If the key exist, input the data into the vector
*of that node. Else find the call the "void Insert(int Key, Node<T> * CurrentNode,T DataObj)"
*to determine where the new node should be created and store the vector into the node identified
*with the key.
*
*
*@param Key - int data type
*@param DataObj - Template Data type
*@return void
*
*/
void Insert(int Key,T DataObj);
/**
*
*@fn InOrderTraversal(InOrderTraversalPtr Print) const
*
*@brief In order Traversal function
*
*This function calls the
*InOrderTraversal(Node<T> * CurrentNode, InOrderTraversalPtr Print) const
*
*@param Print - InOrderTraversalptr (Contains a function to be executed with the same signature)
*@return void
*
*/
void InOrderTraversal(InOrderTraversalPtr Print)const;
/**
*
*@fn PreOrderTraversal(PreOrderTraversalPtr Print)const
*
*@brief Pre order Traversal function
*
*This function calls the
*PreOrderTraversal(Node<T> *CurrentNode, PreOrderTraversalPtr Print) const
*
*
*@param Print - PreOrderTraversalPtr (Contains a function to be executed with the same signature)
*@return void
*
*/
void PreOrderTraversal(PreOrderTraversalPtr Print)const;
/**
*
*@fn PostOrderTraversal(PostOrderTraversalPtr Print) const
*
*@brief Post order Traversal function
*
*
*This function calls the
*PostOrderTraversal(Node<T> *CurrentNode,PostOrderTraversalPtr Print) const
*
*
*@param Print - PostOrderTraversalPtr (Contains a function to be executed with the same signature)
*@return void
*
*/
void PostOrderTraversal(PostOrderTraversalPtr Print) const;
/**
*
*@fn ReturnVec(int Key)
*
*@brief Returns the Vector of the key node
*
*This functions returns the whole Vector of the key node where
*the key node is user inputted.
*
*
*
*@param Key - int type
*@return Vector<T>
*
*/
Vector<T> ReturnVec(int Key);
private:
/// store the pointer of the Root node
Node<T> *m_Root;
/// store the pointer of a Node
Node<T> *m_FindNode;
/// store the Vector Object of a node
Vector<T> m_ReturnVec;
/**
*
*@fn Insert(int Key, Node<T> * CurrentNode,T DataObj)
*
*@brief Inserting of data with the Key, DataObj and the Node Pointer
*
*This function takes in 3 parameter, one which is the key and
*another one which is the data. This function will find where the
*location of the new node should be based on the key and create the
*node. It will then identify the node using the Key and enter the Data into
*it's Vector.
*
*
*@param Key - int data type
*@param DataObj - Template Data type
*@param CurrentNode - Node pointer of template class type
*@return void
*
*/
void Insert(int Key, Node<T> * CurrentNode,T DataObj);
/**
*
*@fn InOrderTraversal(Node<T> * CurrentNode, InOrderTraversalPtr Print) const
*
*@brief In order Traversal function Overloader
*
*This function will traverse through the nodes in the tree
*and print the key of the nodes. it will print the left leaf node
*then the root and lastly the right leaf node in the respective manner.
*The output should be in ascending order.
*
*@param Print - InOrderTraversalptr (Contains a function to be executed with the same signature)
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void InOrderTraversal(Node<T> * CurrentNode, InOrderTraversalPtr Print) const ;
/**
*
*@fn PostOrderTraversal(Node<T> *CurrentNode,PostOrderTraversalPtr Print) const
*
*@brief Post order Traversal function overloader
*
*This function will traverse through the nodes in the tree
*and print the key of the nodes. it will print the left leaf node
*then the right leaf node and lastly the root node in the respective manner.
*
*
*@param Print - InOrderTraversalptr (Contains a function to be executed with the same signature)
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void PostOrderTraversal(Node<T> *CurrentNode,PostOrderTraversalPtr Print)const ;
/**
*
*@fn PreOrderTraversal(Node<T> *CurrentNode, PreOrderTraversalPtr Print) const
*@brief Pre order Traversal function overloader
*
*This function will traverse through the nodes in the tree
*and print the key of the nodes. it will print the Root node
*then the left leaf node and lastly the right leaf node in the respective manner.
*
*
*@param Print - InOrderTraversalptr (Contains a function to be executed with the same signature)
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void PreOrderTraversal(Node<T> *CurrentNode, PreOrderTraversalPtr Print) const ;
/**
*
*@fn Search(int Key, Node<T> *CurrentNode) const
*
*@brief The Searching of the Key
*
*
*This function performs the task of searching through the tree
*by its Key. The function will continue to search until the node is null
*or the key is found if the key is found in the tree returns true else
*returns false.
*
*
*@param Key - int data type
*@param CurrentNode - Node* of template class type
*@return bool
*
*/
bool Search(int Key, Node<T> *CurrentNode) const;
/**
*
*@fn Delete(Node<T> *CurrentNode)
*
*@brief The Deleting of the tree.
*
*
*This function deletes the whole tree with the Post traversal concept
*it deletes the node by, severing the connection to the heap memory
*using the delete keyword and setting the node to nullptr.
*
*
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void Delete(Node<T> *CurrentNode);
/**
*
*@fn AssignVector(Node<T> * CurrentNode, int Key)
*
*@brief Assigning of Vector
*
*Search the tree with the Key and assign the Vector
*of that node with the same key to Vector<T> m_ReturnVec
*
*
*
*@param Key - int data type
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void AssignVector(Node<T> * CurrentNode, int Key);
/**
*
*@fn ReturnNode(int Key,Node<T>* CurrentNode)
*
*@brief Assigning the Node
*
*Search the tree with the Key when the node with the same
*key is found store the pointer of the node to Node<T> *m_FindNode
*
*
*
*@param Key - int data type
*@param CurrentNode - Node* of template class type
*@return void
*
*/
void ReturnNode(int Key,Node<T>* CurrentNode);
/**
*
*@fn GetData(int & Data) const
*
*@brief Get the Key of the node
*
*It returns the value of the parameter, it is used when its traversing through tree.
*
*
*
*@param Data - int Reference
*@return int Reference
*
*/
int& GetData(int & Data) const; //int& GetData(int & Data) const ;
};
//Default constructor
template <class T>
Bst<T>::Bst()
{
m_Root = nullptr; // initialising the root
}
template <class T>
Bst<T>::~Bst()
{
// delete the whole tree.
Delete(m_Root);
}
template <class T>
Vector<T> Bst<T>:: ReturnVec(int Key)
{
AssignVector(m_Root, Key); // assigning the vector to m_ReturnVec
return m_ReturnVec; // return m_ReturnVec
}
template <class T>
void Bst<T>::Insert(int Key,T DataObj)// search the key and store the data.
{
if(m_Root !=nullptr) // if root not null
{
if(!Search(Key)) // if key not found
{
Insert(Key,m_Root,DataObj);
}
else // if key found
{
ReturnNode(Key,m_Root); // assigning m_FindNode to where address node of the found key.
m_FindNode ->YearsData.PushBack(DataObj); // insert the obj into the vector of the node.
}
}
else
{
// root is null
m_Root = new Node<T>;
m_Root -> Key = Key;
m_Root -> YearsData.PushBack(DataObj);
m_Root ->Left = nullptr;
m_Root ->Right = nullptr;
}
}
template <class T>
bool Bst<T>:: Search(int Key) const
{
if(m_Root!=nullptr) // if root not null
{
return Search(Key,m_Root); // call function to return true or false
}
else
{
return false; // else return false
}
}
template <class T>
void Bst<T>::InOrderTraversal( InOrderTraversalPtr Print) const
{
// print the inorder key to screen
InOrderTraversal(m_Root, Print);
}
template <class T>
void Bst<T>::PostOrderTraversal(PostOrderTraversalPtr Print) const
{
// print the postorder key to screen
PostOrderTraversal(m_Root,Print);
}
template <class T>
void Bst<T>::PreOrderTraversal(PreOrderTraversalPtr Print) const
{
// print the preorder key to screen
PreOrderTraversal(m_Root,Print);
}
template <class T>
void Bst<T>:: Insert(int Key, Node<T> * CurrentNode,T DataObj)
{
if(Key>CurrentNode->Key) // if entered key is bigger than root key
{
if(CurrentNode->Right !=nullptr) // check if node right pointer not null
{
Insert(Key,CurrentNode->Right,DataObj); // recursive with root become the right pointer
}
else
{
// if the right pointer is null create a new node and assign data and key
Node <T>* New_Node = new Node<T>;
New_Node -> Key = Key;
New_Node ->YearsData.PushBack(DataObj);
New_Node ->Left = nullptr;
New_Node ->Right = nullptr;
CurrentNode->Right = New_Node; // point new create node to currentNode right pointer
}
}
else // if key is not bigger than root key
{
if(CurrentNode->Left !=nullptr)// check if node left pointer not null
{
Insert(Key,CurrentNode->Left,DataObj); // recursive with root become the left pointer
}
else
{
// if the left pointer is null create a new node and assign data and key
Node<T> * New_Node = new Node<T>;
New_Node->Key = Key;
New_Node ->YearsData.PushBack(DataObj);
New_Node ->Left = nullptr;
New_Node ->Right = nullptr;
CurrentNode->Left = New_Node; // point new create node to currentNode right pointer
}
}
}
template <class T>
int& Bst<T>:: GetData(int& Data) const
{
return Data; // return the parameter value
}
template <class T>
void Bst<T>::InOrderTraversal(Node<T> * CurrentNode,InOrderTraversalPtr Print) const
{
// recursive call
if (CurrentNode->Left !=nullptr) // if left pointer not null
{
InOrderTraversal(CurrentNode->Left,Print); // recursive till left pointer is null
}
Print(GetData(CurrentNode->Key)); // call the print ptr function with getdata function as parameter
if(CurrentNode->Right !=nullptr) // if right pointer not null
{
InOrderTraversal(CurrentNode->Right, Print); // recursive till right pointer is null
}
}
template <class T>
void Bst<T>::PostOrderTraversal(Node<T> *CurrentNode,PostOrderTraversalPtr Print) const
{
if (CurrentNode->Left!=nullptr) // if left pointer not null
{
PostOrderTraversal(CurrentNode->Left,Print);// recursive till left pointer is null
}
if (CurrentNode->Right!=nullptr)// if right pointer not null
{
PostOrderTraversal(CurrentNode->Right,Print);// recursive till right pointer is null
}
Print(GetData(CurrentNode->Key)); // call the print ptr function with getdata function as parameter
}
template <class T>
void Bst<T>::PreOrderTraversal(Node<T> *CurrentNode,PreOrderTraversalPtr Print) const
{
Print(GetData(CurrentNode->Key)); // call the print ptr function with getdata function as parameter
if (CurrentNode->Left!=nullptr) // if left pointer not null
{
PreOrderTraversal(CurrentNode->Left,Print); // recursive till left pointer is null
}
if (CurrentNode->Right!=nullptr)// if right pointer not null
{
PreOrderTraversal(CurrentNode->Right,Print); // recursive till right pointer is null
}
}
template <class T>
bool Bst<T>::Search(int Key, Node<T> *CurrentNode) const
{
if(CurrentNode == nullptr) // Current Node = nullptr
{
return false; //return false
}
else if(Key == CurrentNode->Key) // if key matches node key
{
return true; // return true
}
else if(Key>CurrentNode->Key) // if key is bigger than root node key
{
return Search(Key,CurrentNode->Right); // the root node points right pointer
}
else
{
// if key not bigger than root node key
return Search(Key,CurrentNode->Left); // root node points to left pointer
}
}
template <class T>
void Bst<T>::AssignVector(Node<T> * CurrentNode, int Key)
{
Vector<T> ReturnVec;
if(Key == CurrentNode->Key) // if key matches node key
{
m_ReturnVec = CurrentNode ->YearsData; //Assign the vector to m_ReturnVec
}
else if(Key>CurrentNode->Key) // if key is bigger than root node key
{
AssignVector(CurrentNode->Right,Key); // the root node points right pointer
}
else
{
// if key not bigger than root node key
AssignVector(CurrentNode->Left,Key); // root node points to left pointer
}
}
template <class T>
void Bst<T>::ReturnNode(int Key,Node<T>* CurrentNode)
{
if(Key == CurrentNode->Key) // if key matches node key
{
m_FindNode = CurrentNode; //Assign the node pointer to m_FindNode
}
else if(Key>CurrentNode->Key) // if key is bigger than root node key
{
ReturnNode(Key,CurrentNode->Right); // the root node points right pointer
}
else
{
// if key not bigger than root node key
ReturnNode(Key,CurrentNode->Left); // root node points to left pointer
}
}
template <class T>
void Bst<T>::Delete(Node<T>*CurrentNode)
{
if(CurrentNode->Left!=nullptr)
{
Delete(CurrentNode->Left); //recursive till node left pointer is null
}
if(CurrentNode->Right!=nullptr)
{
Delete(CurrentNode->Right); // recursive till node right pointer is null
}
delete CurrentNode; // sever connection to heap memory with delete keyword
CurrentNode=nullptr; // set the node pointer to null.
}
