#include <string>
-#include "exception/BaseException.h"
+#include <nncc/foundation/Exception.h>
namespace nncc
{
namespace contrib
{
-class ConfigException : public nncc::foundation::BaseException
+class ConfigException : public nncc::foundation::Exception
{
public:
ConfigException() = default;
~ConfigException() throw() override = default;
explicit ConfigException(const std::string &info);
- explicit ConfigException(BaseException &e, const std::string &info);
+ explicit ConfigException(Exception &e, const std::string &info);
};
} // namespace contrib
namespace contrib
{
-ConfigException::ConfigException(const std::string &info) : BaseException(info) {}
+ConfigException::ConfigException(const std::string &info) : Exception(info) {}
-ConfigException::ConfigException(BaseException &e, const std::string &info) : BaseException(e, info)
+ConfigException::ConfigException(Exception &e, const std::string &info) : Exception(e, info)
{
}
namespace foundation
{
-class BaseException : public std::exception
+class Exception : public std::exception
{
public:
- BaseException() = default;
- ~BaseException() throw() override = default;
+ Exception() = default;
+ ~Exception() throw() override = default;
- explicit BaseException(const std::string &info);
- explicit BaseException(BaseException &e, const std::string &info);
+ explicit Exception(const std::string &info);
+ explicit Exception(Exception &e, const std::string &info);
- BaseException &append(const std::string &info);
+ Exception &append(const std::string &info);
const std::vector<std::string> &getInfo() const;
const char *what() const throw() override;
std::vector<std::string> _info;
};
-std::ostream &operator<<(std::ostream &s, const BaseException &e);
+std::ostream &operator<<(std::ostream &s, const Exception &e);
} // namespace foundation
} // namespace nncc
#include <iostream>
#include <stdexcept>
-#include "exception/BaseException.h"
+#include "nncc/foundation/Exception.h"
namespace nncc
{
namespace foundation
{
-BaseException::BaseException(const std::string &info) { _info.push_back(info); }
+Exception::Exception(const std::string &info) { _info.push_back(info); }
-BaseException::BaseException(BaseException &e, const std::string &info)
+Exception::Exception(Exception &e, const std::string &info)
{
for (auto errors : e.getInfo())
{
_info.push_back(info);
}
-const char *BaseException::what() const throw()
+const char *Exception::what() const throw()
{
// TODO implement it
throw std::runtime_error{"Not implemented, yet"};
}
-const std::vector<std::string> &BaseException::getInfo() const { return _info; }
+const std::vector<std::string> &Exception::getInfo() const { return _info; }
-BaseException &BaseException::append(const std::string &info)
+Exception &Exception::append(const std::string &info)
{
_info.push_back(info);
return *this;
}
-std::ostream &operator<<(std::ostream &s, const BaseException &e)
+std::ostream &operator<<(std::ostream &s, const Exception &e)
{
for (auto &errors : e.getInfo())
{
-#include <exception/BaseException.h>
+#include <nncc/foundation/Exception.h>
#include <gtest/gtest.h>
std::vector<std::string> msgs = {errorMsg1, errorMsg2, errorMsg3};
-void err1() { throw BaseException(errorMsg1); }
+void err1() { throw Exception(errorMsg1); }
void err2()
{
{
err1();
}
- catch (BaseException &e)
+ catch (Exception &e)
{
throw e.append(errorMsg2);
}
{
err2();
}
- catch (BaseException &e)
+ catch (Exception &e)
{
- throw BaseException(e, errorMsg3);
+ throw Exception(e, errorMsg3);
}
}
-TEST(FOUNDATION_EXCEPTION, BaseException)
+TEST(FOUNDATION_EXCEPTION, Exception)
{
try
{
err3();
}
- catch (BaseException &e)
+ catch (Exception &e)
{
ASSERT_TRUE(msgs == e.getInfo());
return;