the ds_array manager class

DSArrayManager.h

@@ -0,0 +1,299 @@
+#ifndef _DS_ARRAY_MANAGER
+#define _DS_ARRAY_MANAGER
+
+#include "DSArray.h"
+#include <vector>
+
+class DSArrayManager {
+	private:
+	
+
+	public:
+	//list<DSArray*>* ds_arrays;
+	vector<DSArray*> ds_arrays;
+	DSArray* ds_array_active = nullptr;
+	int ds_array_active_index = -1;
+	int array_count = 0;
+
+	DSArrayManager();
+	~DSArrayManager();
+
+	DSArray* get_ptr( int index );
+
+	int ds_array_create( int d_type, int width, int height );
+	int ds_array_create_fast( int d_type, int width, int height );
+	bool ds_array_exists( int index );
+	bool ds_array_destroy( int index );
+	int ds_array_copy( int index );
+
+	/// Handling
+	void ds_array_set( int index, int x, int y, double val );
+	double ds_array_get( int index, int x, int y );
+	void ds_array_set_region( int index, int x1, int y1, int x2, int y2, double val );
+	void ds_array_clear( int index, double val );
+
+	int ds_array_find_index( int index, double val, int offset );
+
+	/// Target handling
+	void ds_array_target_set( int x, int y, double val );
+	double ds_array_target_get( int x, int y );
+	void ds_array_target_set_region( int x1, int y1, int x2, int y2, double val );
+	void ds_array_target_clear( double val );
+
+	int ds_array_target_find_index( double val, int offset );
+
+	/// Buffers
+	int ds_array_poke( int index, char* address_buffer, size_t offset );
+	int ds_array_peek( int index, char* address_buffer, size_t offset );
+	int ds_array_poke_compressed( int index, char* address_buffer, size_t offset );
+	int ds_array_peek_compressed( int index, char* address_buffer, size_t offset );
+
+	/// Information & Utility
+	int ds_array_size( int index );
+	int ds_array_type( int index );
+	int ds_array_width( int index );
+	int ds_array_height( int index );
+
+	/// Meta
+	/*uint ds_array_find_first();
+	uint ds_array_find_next( uint ds_array );*/
+	int ds_array_indices();
+	int ds_array_count();
+	bool ds_array_set_target( int index );
+	int ds_array_get_target();
+	bool ds_array_has_target();
+	void ds_array_reset_target();
+};
+
+
+
+inline DSArray * DSArrayManager::get_ptr( int index )
+{
+	if( index >= 0 && index < ( int ) this->ds_arrays.size() ) {
+		return this->ds_arrays[ index ];
+	} else {
+		return nullptr;
+	}
+}
+
+
+
+inline DSArrayManager::DSArrayManager()
+{
+	//ds_arrays = new vector<DSArray*>;
+}
+
+inline DSArrayManager::~DSArrayManager()
+{
+	for( auto child : ds_arrays ) {
+		delete child;
+	}
+	ds_arrays.clear();
+	//delete ds_arrays;
+}
+
+inline int DSArrayManager::ds_array_create_fast( int d_type, int width, int height )
+{
+	DSArray* ds_array = new DSArray( d_type, width, height );
+
+	int index;
+	ds_arrays.push_back( ds_array );
+	index = ds_arrays.size() - 1;
+
+	this->array_count++;
+
+	return index;
+}
+
+inline int DSArrayManager::ds_array_create( int d_type, int width, int height )
+{
+	DSArray* ds_array = new DSArray( d_type, width, height );
+
+	int index;
+	auto free_it = std::find( ds_arrays.begin(), ds_arrays.end(), nullptr );
+	if( free_it != ds_arrays.end() ) {
+		index = free_it - ds_arrays.begin();
+		ds_arrays[ index ] = ds_array;
+	} else {
+		ds_arrays.push_back( ds_array );
+		index = ds_arrays.size() - 1;
+	}
+
+	this->array_count++;
+
+	return index;
+}
+
+inline bool DSArrayManager::ds_array_exists( int index )
+{
+	return ( this->get_ptr( index ) != nullptr );
+}
+
+inline bool DSArrayManager::ds_array_destroy( int index )
+{
+	if( this->ds_array_exists( index ) ) {
+		DSArray* ptr = this->get_ptr( index );
+		ds_arrays[ index ] = nullptr;
+		delete ptr;
+
+		if( this->ds_array_active == ptr ) {
+			this->ds_array_active = nullptr;
+			this->ds_array_active_index = -1;
+		}
+
+		this->array_count--;
+		return true;
+	}
+	return false;
+}
+
+inline int DSArrayManager::ds_array_copy( int index )
+{
+	if( this->ds_array_exists( index ) ) {
+		DSArray* ptr = this->get_ptr( index );
+		int copy = this->ds_array_create( ptr->type, ptr->width, ptr->height );
+		DSArray* copy_ptr = this->get_ptr( copy );
+		ptr->write( ( char* ) copy_ptr->data->get_address(), 0 );
+		return copy;
+	}
+	return -1;
+}
+
+/// Handling
+
+inline void DSArrayManager::ds_array_set( int index, int x, int y, double val )
+{
+	this->ds_arrays[ index ]->set( x, y, val );
+}
+
+inline double DSArrayManager::ds_array_get( int index, int x, int y )
+{
+	return this->ds_arrays[ index ]->get( x, y );
+}
+
+inline void DSArrayManager::ds_array_set_region( int index, int x1, int y1, int x2, int y2, double val )
+{
+	this->ds_arrays[ index ]->set_region( x1, y1, x2, y2, val );
+}
+
+inline void DSArrayManager::ds_array_clear( int index, double val )
+{
+	return this->ds_arrays[ index ]->clear( val );
+}
+
+inline int DSArrayManager::ds_array_find_index( int index, double val, int offset )
+{
+	return this->ds_arrays[ index ]->find_index( val, offset );
+}
+
+/// Targets
+
+inline void DSArrayManager::ds_array_target_set( int x, int y, double val )
+{
+	ds_array_active->set( x, y, val );
+}
+
+inline double DSArrayManager::ds_array_target_get( int x, int y )
+{
+	return ds_array_active->get( x, y );
+}
+
+inline void DSArrayManager::ds_array_target_set_region( int x1, int y1, int x2, int y2, double val )
+{
+	this->ds_array_active->set_region( x1, y1, x2, y2, val );
+}
+
+inline void DSArrayManager::ds_array_target_clear( double val )
+{
+	return this->ds_array_active->clear( val );
+}
+
+inline int DSArrayManager::ds_array_target_find_index( double val, int offset )
+{
+	return this->ds_array_active->find_index( val, offset );
+}
+
+/// Buffers
+
+inline int DSArrayManager::ds_array_poke( int index, char * address_buffer, size_t offset )
+{
+	return this->ds_arrays[ index ]->write( address_buffer, offset );
+}
+
+inline int DSArrayManager::ds_array_peek( int index, char * address_buffer, size_t offset )
+{
+	return this->ds_arrays[ index ]->read( address_buffer, offset );
+}
+
+inline int DSArrayManager::ds_array_poke_compressed( int index, char * address_buffer, size_t offset )
+{
+	return this->ds_arrays[ index ]->write_compressed( address_buffer, offset );
+}
+
+inline int DSArrayManager::ds_array_peek_compressed( int index, char * address_buffer, size_t offset )
+{
+	return this->ds_arrays[ index ]->read_compressed( address_buffer, offset );
+}
+
+/// Information & Utility
+
+inline int DSArrayManager::ds_array_size( int index )
+{
+	return this->ds_arrays[ index ]->data->bytesize();
+}
+
+inline int DSArrayManager::ds_array_type( int index )
+{
+	return this->ds_arrays[ index ]->type;
+}
+
+inline int DSArrayManager::ds_array_width( int index )
+{
+	return this->ds_arrays[ index ]->width;
+}
+
+inline int DSArrayManager::ds_array_height( int index )
+{
+	return this->ds_arrays[ index ]->height;
+}
+
+/// Meta
+inline int DSArrayManager::ds_array_count()
+{
+	return this->array_count;
+}
+
+inline int DSArrayManager::ds_array_indices()
+{
+	return ds_arrays.size();
+}
+
+inline bool DSArrayManager::ds_array_set_target( int index )
+{
+	DSArray* ptr = this->get_ptr( index );
+	if( ptr != nullptr ) {
+		ds_array_active_index = index;
+		ds_array_active = ptr;
+		return true;
+	}
+	return false;
+}
+
+inline int DSArrayManager::ds_array_get_target()
+{
+	return ds_array_active_index;
+}
+
+inline bool DSArrayManager::ds_array_has_target()
+{
+	return( ds_array_active_index != -1);
+}
+
+inline void DSArrayManager::ds_array_reset_target()
+{
+	ds_array_active = nullptr;
+	ds_array_active_index = -1;
+}
+
+
+#endif