File Clocks.H

#pragma once

#include "Time.h"

class Clocks :

public Time

{

public:

Clocks();

Clocks(time_t h, time_t m, time_t s);

explicit Clocks(std::string_view str);

bool setTime(time_t h, time_t m, time_t s) override;

};

File Clocks.Cpp

#include "Clocks.h"

Clocks::Clocks()

: Time()

{

}

Clocks::Clocks(time_t h, time_t m, time_t s)

{

Clocks::setTime(h, m, s);

}

Clocks::Clocks(std::string_view str)

{

Clocks::parseString(str);

}

bool Clocks::setTime(time_t h, time_t m, time_t s)

{

if (h < 0 || h > 23 || m < 0 || m > 59 || s < 0 || s > 59)

{

h = m = s = 0;

return false;

}

this->hours = h;

this->minutes = m;

this->seconds = s;

return true;

}

File iSerializable.H

#pragma once

#include "stdafx.cpp"

template<typename ObjectType, typename WriteToBuffer, typename ReadFrom>

class ISerializable

{

public:

virtual ObjectType getType() const = 0;

virtual std::string_view getTypeString() const = 0;

virtual void serialize(WriteToBuffer& out) const = 0;

virtual void deserialize(ReadFrom& ss) = 0;

virtual ~ISerializable() = default;

};

File iEmissionable.H

#pragma once

#include "ISerializable.h"

class IEmissionable

{

protected:

double emissionFactor;

public:

IEmissionable() = delete;

explicit IEmissionable(double emissionFactor) : emissionFactor(emissionFactor) { }

virtual ~IEmissionable() = default;

virtual double calculateFuelConsumption(double distance) const = 0;

virtual double calculateEmissions(double distance) const = 0;

};

File iCloneable.H

#pragma once

#include "IEmissionable.h"

template<typename TypeToClone>

class ICloneable

{

static_assert(std::is_pointer_v<TypeToClone>, "Type that implements ICloneable must be a pointer");

public:

using pointer_type = TypeToClone;

virtual pointer_type clone() const = 0;

};

File stdafx.H

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

#include <format>

#include <string>

#include <vector>

#include <fstream>

#include <algorithm>

#include <sstream>

#include <numbers>

#include <unordered_map>

#include <nlohmann/json.hpp>

enum TransportTypes

{

None,

E_Train,

E_Bus,

E_Plane,

E_AllTrans,

E_NumberOfTrans

};

//Global functions

inline static void clearBuffer(std::istream& in)

{

in.clear();

in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

}

template<typename Object, typename Function>

static void validateInput(Object& data, std::istream& in, Function foo, char const* text = "Incorrect input. Try again: ")

{

while (true)

{

in >> data;

if (!foo(data) || in.fail())

{

clearBuffer(in);

std::cout << text;

}

else break;

}

}

template<typename Object>

static void validateInput(Object& data, std::istream& in, char const* text = "Incorrect input. Try again: ")

{

while (true)

{

in >> data;

if (in.fail())

{

clearBuffer(in);

std::cout << text;

}

else break;

}

}