/**
 * @file cppfeatures_test
 * @author Vir
 * @date 2021-03
 * @brief cpp features
 *
 * $LicenseInfo:firstyear=2021&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2021, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

// Tests related to newer C++ features, for verifying support across compilers and platforms

#include "linden_common.h"
#include "../test/lltut.h"

namespace tut
{

struct cpp_features_test {};
typedef test_group<cpp_features_test> cpp_features_test_t;
typedef cpp_features_test_t::object cpp_features_test_object_t;
tut::cpp_features_test_t tut_cpp_features_test("LLCPPFeatures");

// bracket initializers
// Can initialize containers or values using curly brackets
template<> template<>
void cpp_features_test_object_t::test<1>()
{
	S32 explicit_val{3};
	ensure(explicit_val==3);

	S32 default_val{};
	ensure(default_val==0);
	
	std::vector<S32> fibs{1,1,2,3,5};
	ensure(fibs[4]==5);
}

// auto
//
// https://en.cppreference.com/w/cpp/language/auto
// 
// Can use auto in place of a more complex type specification, if the compiler can infer the type
template<> template<>
void cpp_features_test_object_t::test<2>()
{
	std::vector<S32> numbers{3,6,9};

	// auto element
	auto& aval = numbers[1];
	ensure("auto element", aval==6);

	// auto iterator (non-const)
	auto it = numbers.rbegin();
	*it += 1;
	S32 val = *it;
	ensure("auto iterator", val==10);
}

// range for
//
// https://en.cppreference.com/w/cpp/language/range-for
//
// Can iterate over containers without explicit iterator
template<> template<>
void cpp_features_test_object_t::test<3>()
{

	// Traditional iterator for with container
	//
	// Problems:
	// * Have to create a new variable for the iterator, which is unrelated to the problem you're trying to solve.
	// * Redundant and somewhat fragile. Have to make sure begin() and end() are both from the right container.
	std::vector<S32> numbers{3,6,9};
	for (auto it = numbers.begin(); it != numbers.end(); ++it)
	{
		auto& n = *it;
		n *= 2;
	}
	ensure("iterator for vector", numbers[2]==18);

	// Range for with container
	//
	// Under the hood, this is doing the same thing as the traditional
	// for loop above. Still uses begin() and end() but you don't have
	// to access them directly.
	std::vector<S32> numbersb{3,6,9};
	for (auto& n: numbersb)
	{
		n *= 2;
	}
	ensure("range for vector", numbersb[2]==18);

	// Range for over a C-style array.
	//
	// This is handy because the language determines the range automatically.
	// Getting this right manually is a little trickier.
	S32 pows[] = {1,2,4,8,16};
	S32 sum{};
	for (const auto& v: pows)
	{
		sum += v;
	}
	ensure("for C-array", sum==31);
}

// override specifier
//
// https://en.cppreference.com/w/cpp/language/override
//
// Specify that a particular class function is an override of a virtual function.
// Benefits:
// * Makes code somewhat easier to read by showing intent.
// * Prevents mistakes where you think something is an override but it doesn't actually match the declaration in the parent class.
// Drawbacks:
// * Some compilers require that any class using override must use it consistently for all functions. 
//   This makes switching a class to use override a lot more work. 

class Foo
{
public:
	virtual bool is_happy() const = 0;
};

class Bar: public Foo
{
public:
	bool is_happy() const override { return true; } 
	// Override would fail: non-const declaration doesn't match parent 
	// bool is_happy() override { return true; } 
	// Override would fail: wrong name
	// bool is_happx() override { return true; } 
};

template<> template<>
void cpp_features_test_object_t::test<4>()
{
	Bar b;
	ensure("override", b.is_happy());
}

// final
//
// https://en.cppreference.com/w/cpp/language/final: "Specifies that a
// virtual function cannot be overridden in a derived class or that a
// class cannot be inherited from."

class Vehicle
{
public:
	virtual bool has_wheels() const = 0;
};

class WheeledVehicle: public Vehicle
{
public:
	virtual bool has_wheels() const final override { return true; }
};

class Bicycle: public WheeledVehicle
{
public:
	// Error: can't override final version in WheeledVehicle 
	// virtual bool has_wheels() override const { return true; }
};

template<> template<>
void cpp_features_test_object_t::test<5>()
{
	Bicycle bi;
	ensure("final", bi.has_wheels());
}

// deleted function declaration
//
// https://en.cppreference.com/w/cpp/language/function#Deleted_functions
//
// Typical case: copy constructor doesn't make sense for a particular class, so you want to make
// sure the no one tries to copy-construct an instance of the class, and that the
// compiler won't generate a copy constructor for  you automatically.
// Traditional fix is to declare a
// copy constructor but never implement it, giving you a link-time error if anyone tries to use it.
// Now you can explicitly declare a function to be deleted, which has at least two advantages over
// the old way:
// * Makes the intention clear
// * Creates an error sooner, at compile time

class DoNotCopy
{
public:
	DoNotCopy() {}
	DoNotCopy(const DoNotCopy& ref) = delete;
};

template<> template<>
void cpp_features_test_object_t::test<6>()
{
	DoNotCopy nc; // OK, default constructor
	//DoNotCopy nc2(nc); // No, can't copy
	//DoNotCopy nc3 = nc; // No, this also calls copy constructor (even though it looks like an assignment)
}

// defaulted function declaration
//
// https://en.cppreference.com/w/cpp/language/function#Function_definition
//
// What about the complementary case to the deleted function declaration, where you want a copy constructor
// and are happy with the default implementation the compiler will make (memberwise copy).
// Now you can explicitly declare that too.
// Usage: I guess it makes the intent clearer, but otherwise not obviously useful.
class DefaultCopyOK
{
public:
	DefaultCopyOK(): mVal(123) {}
	DefaultCopyOK(const DefaultCopyOK&) = default;
	S32 val() const { return mVal; }
private:
	S32 mVal;
};

template<> template<>
void cpp_features_test_object_t::test<7>()
{
	DefaultCopyOK d; // OK
	DefaultCopyOK d2(d); // OK
	DefaultCopyOK d3 = d; // OK
	ensure("default copy d", d.val()==123);
	ensure("default copy d2", d.val()==d2.val());
	ensure("default copy d3", d.val()==d3.val());
}

// initialize class members inline
//
// https://en.cppreference.com/w/cpp/language/data_members#Member_initialization
//
// Default class member values can be set where they are declared, using either brackets or =

// It is preferred to skip creating a constructor if all the work can be done by inline initialization:
// http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#c45-dont-define-a-default-constructor-that-only-initializes-data-members-use-in-class-member-initializers-instead
//
class InitInline
{
public:
	S32 mFoo{10};
};

class InitInlineWithConstructor
{
public:
	// Here mFoo is not specified, so you will get the default value of 10.
	// mBar is specified, so 25 will override the default value.
	InitInlineWithConstructor():
		mBar(25)
	{}

	// Default values set using two different styles, same effect.
	S32 mFoo{10};
	S32 mBar = 20;
};

template<> template<>
void cpp_features_test_object_t::test<8>()
{
	InitInline ii;
	ensure("init member inline 1", ii.mFoo==10);

	InitInlineWithConstructor iici;
	ensure("init member inline 2", iici.mFoo=10);
	ensure("init member inline 3", iici.mBar==25);
}

// constexpr
//
// https://en.cppreference.com/w/cpp/language/constexpr
//
// Various things can be computed at compile time, and flagged as constexpr.
constexpr S32 compute2() { return 2; }

constexpr S32 ce_factorial(S32 n)
{
	if (n<=0)
	{
		return 1;
	}
	else
	{
		return n*ce_factorial(n-1);
	}
}

template<> template<>
void cpp_features_test_object_t::test<9>()
{
	S32 val = compute2();
	ensure("constexpr 1", val==2);

	// Compile-time factorial. You used to need complex templates to do something this useless.
	S32 fac5 = ce_factorial(5);
	ensure("constexpr 2", fac5==120);
}

// static assert
//
// https://en.cppreference.com/w/cpp/language/static_assert
//
// You can add asserts to be checked at compile time. The thing to be checked must be a constexpr.
// There are two forms:
// * static_assert(expr);
// * static_assert(expr, message);
//
// Currently only the 2-parameter form works on windows. The 1-parameter form needs a flag we don't set.

template<> template<>
void cpp_features_test_object_t::test<10>()
{
	// static_assert(ce_factorial(6)==720); No, needs a flag we don't currently set.
	static_assert(ce_factorial(6)==720, "bad factorial"); // OK
}

// type aliases
//
// https://en.cppreference.com/w/cpp/language/type_alias
// 
// You can use the "using" statement to create simpler templates that
// are aliases for more complex ones. "Template typedef"

// This makes stringmap<T> an alias for std::map<std::string, T>
template<typename T>
using stringmap = std::map<std::string, T>;

template<> template<>
void cpp_features_test_object_t::test<11>()
{
	stringmap<S32> name_counts{ {"alice", 3}, {"bob", 2} };
	ensure("type alias", name_counts["bob"]==2);
}

// Other possibilities:

// nullptr

// class enums

// std::unique_ptr and make_unique

// std::shared_ptr and make_shared

// lambdas

// perfect forwarding

// variadic templates

// std::thread

// std::mutex

// thread_local

// rvalue reference &&

// move semantics

// std::move

// string_view

} // namespace tut