template <>
inline constexpr bool Upp::is_upp_guest<std::string> = true;

template<> inline hash_t Upp::GetHashValue(const std::string& a)
{
	return memhash(a.data(), a.length());
}


CONSOLE_APP_MAIN
{
	{
		Vector<std::string> h;
		for(int i = 0; i < 20; i++)
			h << AsString(i).ToStd();
		RDUMP(h);
		Vector<int> rem = { 1, 2, 3 };
		h.Remove(rem);
		RDUMP(h);
		h.RemoveIf([&](int i) { return h[i].back() == '8'; });
		RDUMP(h);
		Vector<std::string> n = { "21", "22", "23" };
		h.Insert(2, n);
		RDUMP(h);
		h.Insert(2, pick(n));
		RDUMP(h);
		h.Remove(2, 3);
		RDUMP(h);
	}
	{
		Index<std::string> x { "one", "two", "three" };
		RDUMP(x);
		RDUMP(x.Find("two"));
	}
}

template <class T>
struct TriviallyRelocatable {};

struct Foo : MoveableAndDeepCopyOption<Foo> {
...
};

struct Foo : Moveable<Foo, FooBase> ...

struct Foo : Moveable<Foo>, FooBase ...

namespace test {
    struct Test;
}

namespace test {
    struct Test : Moveable<Test> {

        Vector<Test> children;
    };
}

template <> inline constexpr bool is_upp_guest<test::Test> = true;

template <> inline constexpr bool is_trivially_relocatable<test::Test> = true;

struct Test01;

struct Test01 {

    struct Test02 : Moveable<Test02> {

        Vector<Test02> children;
    };
};

template <class T>
inline typename std::enable_if_t<!is_trivially_relocatable<T>> Relocate(T *dst, T *src)
{
	static_assert(is_upp_guest<T>);
	new(dst) T(pick(*src));
	Destruct(src);
}