--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/foosdk/sdk/pfc/sort.h	Mon Jan 05 02:15:46 2026 -0500
@@ -0,0 +1,194 @@
+#pragma once
+
+#include "array.h"
+
+namespace pfc {
+
+	void swap_void(void * item1,void * item2,t_size width);
+
+	void reorder_void(void * data,t_size width,const t_size * order,t_size num,void (*swapfunc)(void * item1,void * item2,t_size width) = swap_void);
+
+	class NOVTABLE reorder_callback
+	{
+	public:
+		virtual void swap(t_size p_index1,t_size p_index2) = 0;
+	};
+
+	void reorder(reorder_callback & p_callback,const t_size * p_order,t_size p_count);
+
+	template<typename t_container>
+	class reorder_callback_impl_t : public reorder_callback
+	{
+	public:
+		reorder_callback_impl_t(t_container & p_data) : m_data(p_data) {}
+		void swap(t_size p_index1,t_size p_index2)
+		{
+			pfc::swap_t(m_data[p_index1],m_data[p_index2]);
+		}
+	private:
+		t_container & m_data;
+	};
+
+	class reorder_callback_impl_delta : public reorder_callback
+	{
+	public:
+		reorder_callback_impl_delta(reorder_callback & p_data,t_size p_delta) : m_data(p_data), m_delta(p_delta) {}
+		void swap(t_size p_index1,t_size p_index2)
+		{
+			m_data.swap(p_index1+m_delta,p_index2+m_delta);
+		}
+	private:
+		reorder_callback & m_data;
+		t_size m_delta;
+	};
+
+	template<typename t_container>
+	void reorder_t(t_container & p_data,const t_size * p_order,t_size p_count)
+	{
+        reorder_callback_impl_t<t_container> cb(p_data);
+		reorder(cb,p_order,p_count);
+	}
+
+	template<typename t_container>
+	void reorder_partial_t(t_container & p_data,t_size p_base,const t_size * p_order,t_size p_count)
+	{
+        reorder_callback_impl_t<t_container> cb1(p_data);
+        reorder_callback_impl_delta cb2( cb1, p_base );
+		reorder(cb2,p_order,p_count);
+//		reorder(reorder_callback_impl_delta(reorder_callback_impl_t<t_container>(p_data),p_base),p_order,p_count);
+	}
+	
+	template<typename T>
+	class reorder_callback_impl_ptr_t : public reorder_callback
+	{
+	public:
+		reorder_callback_impl_ptr_t(T * p_data) : m_data(p_data) {}
+		void swap(t_size p_index1,t_size p_index2)
+		{
+			pfc::swap_t(m_data[p_index1],m_data[p_index2]);
+		}
+	private:
+		T* m_data;
+	};
+
+
+	template<typename T>
+	void reorder_ptr_t(T* p_data,const t_size * p_order,t_size p_count)
+	{
+        reorder_callback_impl_ptr_t<T> cb(p_data);
+		reorder(cb,p_order,p_count);
+	}
+
+
+
+	class NOVTABLE sort_callback
+	{
+	public:
+		virtual int compare(t_size p_index1, t_size p_index2) const = 0;
+		virtual void swap(t_size p_index1, t_size p_index2) = 0;
+		void swap_check(t_size p_index1, t_size p_index2) {if (compare(p_index1,p_index2) > 0) swap(p_index1,p_index2);}
+	};
+
+	class sort_callback_stabilizer : public sort_callback
+	{
+	public:
+		sort_callback_stabilizer(sort_callback & p_chain,t_size p_count);
+		virtual int compare(t_size p_index1, t_size p_index2) const;
+		virtual void swap(t_size p_index1, t_size p_index2);
+	private:
+		sort_callback & m_chain;
+		array_t<t_size> m_order;
+	};
+
+	void sort(sort_callback & p_callback,t_size p_count);
+	void sort_stable(sort_callback & p_callback,t_size p_count);
+
+	void sort_void_ex(void *base,t_size num,t_size width, int (*comp)(const void *, const void *),void (*swap)(void *, void *, t_size) );
+	void sort_void(void * base,t_size num,t_size width,int (*comp)(const void *, const void *) );
+
+	template<typename t_container,typename t_compare>
+	class sort_callback_impl_simple_wrap_t : public sort_callback
+	{
+	public:
+		sort_callback_impl_simple_wrap_t(t_container & p_data, t_compare p_compare) : m_data(p_data), m_compare(p_compare) {}
+		int compare(t_size p_index1, t_size p_index2) const
+		{
+			return m_compare(m_data[p_index1],m_data[p_index2]);
+		}
+
+		void swap(t_size p_index1, t_size p_index2)
+		{
+			swap_t(m_data[p_index1],m_data[p_index2]);
+		}
+	private:
+		t_container & m_data;
+		t_compare m_compare;
+	};
+
+	template<typename t_container>
+	class sort_callback_impl_auto_wrap_t : public sort_callback
+	{
+	public:
+		sort_callback_impl_auto_wrap_t(t_container & p_data) : m_data(p_data) {}
+		int compare(t_size p_index1, t_size p_index2) const
+		{
+			return compare_t(m_data[p_index1],m_data[p_index2]);
+		}
+
+		void swap(t_size p_index1, t_size p_index2)
+		{
+			swap_t(m_data[p_index1],m_data[p_index2]);
+		}
+	private:
+		t_container & m_data;
+	};
+
+	template<typename t_container,typename t_compare,typename t_permutation>
+	class sort_callback_impl_permutation_wrap_t : public sort_callback
+	{
+	public:
+		sort_callback_impl_permutation_wrap_t(const t_container & p_data, t_compare p_compare,t_permutation const & p_permutation) : m_data(p_data), m_compare(p_compare), m_permutation(p_permutation) {}
+		int compare(t_size p_index1, t_size p_index2) const
+		{
+			return m_compare(m_data[m_permutation[p_index1]],m_data[m_permutation[p_index2]]);
+		}
+
+		void swap(t_size p_index1, t_size p_index2)
+		{
+			swap_t(m_permutation[p_index1],m_permutation[p_index2]);
+		}
+	private:
+		const t_container & m_data;
+		t_compare m_compare;
+		t_permutation const & m_permutation;
+	};
+
+	template<typename t_container,typename t_compare>
+	static void sort_t(t_container & p_data,t_compare p_compare,t_size p_count)
+	{
+        sort_callback_impl_simple_wrap_t<t_container,t_compare> cb(p_data,p_compare);
+		sort(cb,p_count);
+	}
+
+	template<typename t_container,typename t_compare>
+	static void sort_stable_t(t_container & p_data,t_compare p_compare,t_size p_count)
+	{
+        sort_callback_impl_simple_wrap_t<t_container,t_compare> cb(p_data,p_compare);
+		sort_stable(cb,p_count);
+	}
+
+	template<typename t_container,typename t_compare,typename t_permutation>
+	static void sort_get_permutation_t(const t_container & p_data,t_compare p_compare,t_size p_count,t_permutation const & p_permutation)
+	{
+        sort_callback_impl_permutation_wrap_t<t_container,t_compare,t_permutation> cb(p_data,p_compare,p_permutation);
+		sort(cb,p_count);
+	}
+
+	template<typename t_container,typename t_compare,typename t_permutation>
+	static void sort_stable_get_permutation_t(const t_container & p_data,t_compare p_compare,t_size p_count,t_permutation const & p_permutation)
+	{
+        sort_callback_impl_permutation_wrap_t<t_container,t_compare,t_permutation> cb(p_data,p_compare,p_permutation);
+		sort_stable(cb,p_count);
+	}
+
+}