test.cpp

#include "container.h"

// Just a plain pod with trivial constructor
struct Pod
{
	int x = 0;
};

// Pod with a constructor that takes an argument
struct PodWithInt
{
	int x;

	PodWithInt (int n) : x { n }
	{
	}
};

// The constructor here takes the container.
// This allows to manually "inject" the dependencies into the class.
// Of course it is not the true DI but it is as close as we can get.
struct PodWithContainer
{
	Pod &pod;
	PodWithInt &pod_with_int;

	PodWithContainer (maxy::control::Container &c) :

		pod { c.get<Pod> () },
		pod_with_int { c.get<PodWithInt> () }
	{
	}
};

// Same as above but with additional arguments to the constructor
struct PodWithContainerAndInt
{
	PodWithInt pod_with_int;
	PodWithInt &pod_with_int_ref;

	PodWithContainerAndInt (maxy::control::Container &c, int n) :
		pod_with_int { n },
		pod_with_int_ref { c.get<PodWithInt> () }
	{
	}
};


int main ()
{
	std::cout << "Testing\n" << std::boolalpha;

	maxy::control::Container c;

	// Register some classes
	c.add<Pod> ();
	c.add<PodWithInt> (666);
	c.add<PodWithContainer> ();
	c.add<PodWithContainerAndInt> (1234);

	// Get an instance from the container
	auto &pod = c.get<Pod> ();
	std::cout << "Pod.x is 0 : " << (pod.x == 0) << "\n";

	// The container holds singletons so pod and pod2 point to the same instance!
	auto &pod2 = c.get<Pod> ();
	// So this changes pod as well
	pod2.x = 555;

	std::cout << "Pod.x changed to 555 : " << (pod.x == 555) << "\n";

	// Get a couple more instances from the container
	auto & pod_with_int = c.get<PodWithInt> ();
	auto & pod_with_container = c.get<PodWithContainer> ();

	std::cout << "pod_with_container.pod.x = 555 : " << (pod_with_container.pod.x == 555) 
		<< ", pod_with_container.pod_with_int.x = 666 : " << (pod_with_container.pod_with_int.x == 666) << "\n";

	// Now modify instances retrieved earlier
	pod.x = 333;
	pod_with_int.x = 888;

	// The dependencies inside the pod_with_container are references to container-stored singletons too, so they were just modified.
	std::cout << "pod_with_container.pod.x = 333 : " << (pod_with_container.pod.x == 333) 
		<< ", pod_with_container.pod_with_int.x = 888 : " << (pod_with_container.pod_with_int.x == 888) << "\n";

	auto pod_with_container_and_int = c.get<PodWithContainerAndInt> ();
	// pod_with_container_and_int.pod_with_int is not a reference and therefore it retains the value provided at the time of registration.
	// However its 'pod_with_int_ref' property is a reference to the global singleton so its value is now changed as expected.
	std::cout << "pod_with_container_and_int.pod_with_int.x = 1234 : " << (pod_with_container_and_int.pod_with_int.x == 1234) 
		<< ", pod_with_container_and_int.pod_with_int_ref.x = 888 : " << (pod_with_container_and_int.pod_with_int_ref.x == 888) << "\n";

	std::cout << "Done\n";
}