/*
 * Copyright 2021 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _ERRORS_EXT_H
#define _ERRORS_EXT_H

#include <iosfwd>

#include <String.h>
#include <SupportDefs.h>

class BDataIO;


namespace BPrivate {

namespace Network {


class BError
{
public:
								BError(const char* origin);
								BError(BString origin);
	virtual						~BError() noexcept;

								BError(const BError& error);
								BError(BError&& error) noexcept;

			BError&				operator=(const BError& error);
			BError&				operator=(BError&& error) noexcept;

	virtual	const char*			Message() const noexcept = 0;
	virtual	const char*			Origin() const noexcept;
	virtual	BString				DebugMessage() const;
			void				WriteToStream(std::ostream& stream) const;
			size_t				WriteToOutput(BDataIO* output) const;

private:
	virtual	void				_ReservedError1();
	virtual	void				_ReservedError2();
	virtual	void				_ReservedError3();
	virtual	void				_ReservedError4();

private:
			BString				fOrigin;
};


class BRuntimeError : public BError
{
public:
								BRuntimeError(const char* origin, const char* message);
								BRuntimeError(const char* origin, BString message);
								BRuntimeError(BString origin, BString message);

								BRuntimeError(const BRuntimeError& other);
								BRuntimeError(BRuntimeError&& other) noexcept;

			BRuntimeError&		operator=(const BRuntimeError& other);
			BRuntimeError&		operator=(BRuntimeError&& other) noexcept;

	virtual	const char*			Message() const noexcept override;

private:
			BString				fMessage;
};


class BSystemError : public BError
{
public:
								BSystemError(const char* origin, status_t error);
								BSystemError(BString origin, status_t error);

								BSystemError(const BSystemError& other);
								BSystemError& operator=(const BSystemError& other);

								BSystemError(BSystemError&& other) noexcept;
								BSystemError& operator=(BSystemError&& other) noexcept;

	virtual	const char*			Message() const noexcept override;
	virtual	BString				DebugMessage() const override;
			status_t			Error() noexcept;

private:
			status_t			fErrorCode;
};

} // namespace Network

} // Namespace BPrivate

#endif // _ERRORS_EXT_H