/******************************************************************************/
/* MULTI-ARRAYS ***************************************************************/
/******************************************************************************/

#ifndef _H_EBCL_MULTIARRAYS
#define _H_EBCL_MULTIARRAYS
#include <ebcl/Arrays.hh>
#include <ebcl/Strings.hh>
namespace ebcl {


/*= MULTI-ARRAYS ============================================================-*/
/*
 * Arrays that allow storing multiple values for one entry. Values must be
 * added in order.
 */

template< typename T >
class T_MultiArray
{
   public:
	using T_Data = T_Array< T >;

   private:
	typedef T_MultiArray< T > MyType_;

	T_Array< uint32_t > meta_;
	T_Data values_;

   public:
	M_TEMPLATE_POINTERS( T_MultiArray );

	template< typename TP >
	friend void swap( T_MultiArray< TP >& lhs , T_MultiArray< TP >& rhs );

	// Start the next entry
	void next( );
	// Add a value to the current entry
	void add( T value );
	// Add a value, calling its constructor
	template<
		typename Q = T ,
		typename... Args ,
		typename = std::enable_if_t< std::is_class< Q >::value >
		>
	Q& addNew( Args&& ... args );
	// Copy an array's contents into the current entry
	void copyFrom( T_Data const& source );

	// Returns the amount of entries
	uint32_t size( ) const noexcept;
	// Returns the index of the first value for an entry
	uint32_t firstOf( uint32_t item ) const noexcept;
	// Returns the amount of values for an entry
	uint32_t sizeOf( uint32_t item ) const noexcept;
	// Returns the amount of values across all entries
	uint32_t values( ) const noexcept;

	// Access a value in an entry
	T const& get( uint32_t item , uint32_t sub ) const;
	T& get( uint32_t item , uint32_t sub );

	// Access a value using its index
	T const& operator[] ( uint32_t index ) const;
	T& operator[] ( uint32_t index );

	// Is a value present in an entry?
	bool contains( uint32_t index , T const& value ) const;

	// Reset storage, don't free memory
	void clear( );
	// Reset storage and free memory
	void free( );

	// Copy values from an entry into the current entry
	void copyFrom( uint32_t index );
	// Copy another multi-array's entry into the current entry
	void copyFrom( MyType_ const& other , uint32_t index );

	// Copy values from another entry into the current entry if
	// they are not already present. Duplicate entries in the
	// source array are still copied, though.
	void copyUnique( uint32_t index );
	// Copy another multi-array's entry into the current entry,
	// ignoring values that are already present. Duplicates in
	// the source array are still copied.
	void copyUnique( MyType_ const& other , uint32_t index );

	// Sort an entry's values
	void sort( uint32_t index , F_Comparator< T > cmp = T_Comparator< T >::compare );
};


// Instantiate some common types directly
extern template class T_MultiArray< uint32_t >;
extern template class T_MultiArray< T_String >;


}
#endif // _H_EBCL_MULTIARRAYS
#include <ebcl/inline/MultiArrays.hh>