Koodit: C++: Kuvien lataus ja säilöntä helposti (SDL)

// Otsikot pitää sisällyttää vain kerran.
// Tämä varmistetaan esikääntäjällä.
#ifndef IMAGE_CACHE_HPP
#define IMAGE_CACHE_HPP

// Käytetään joitakin standardikirjaston luokkia.
#include <string>
#include <map>
#include <stdexcept>

// Tehdään ensin yleinen cache-luokan malli, jossa ovat yleispätevät funktiot.
// T: säilöttävästä tyypistä luotu rakenne, jossa ovat staattiset jäsenet
//    - typedef  ???  type;       // säilöttävä tyyppi,
//    - void free(type& t);       // funktio arvon vapauttamiseen,
//    - type null();              // funktio, joka palauttaa tyhjän arvon,
//    - void null(type const& t); // funktio, joka tarkistaa, onko arvo tyhjä.
// K: avaimen tyyppi; oletuksena std::string
// C: tietorakenne tallennukseen; oletuksena std::map<K, T::type>.
template <typename T, typename K = std::string, typename C = std::map<K, typename T::type> > class cache {
	// Säilöjä ei kuulu kopioida, joten kopiomuodostin on yksityinen.
	cache(const cache& t) {
		throw std::logic_error("cache(const cache& t)");
	}
protected:
	// Tyypit: avain, säilöttävä objekti, tietorakenne,
	// tietorakenteen iteraattori sekä tämä luokka itse.
	typedef K key;
	typedef typename T::type object;
	typedef C container;
	typedef typename container::iterator iterator;
	typedef cache<T, K, C> cache_type;

	// Data aiemmin määrätyssä tietorakenteessa (map)
	container data;

	// Muodostin on tyhjä.
	cache() {}
public:
	// Jäsenen asetus: poistetaan vanha, lisätään uusi, jos se ei ole tyhjä.
	void set(const key& k, object t) {
		erase(k);
		if (T::is_null(t)) {
			data[k] = t;
		}
	}
	// Haku: etsitään ja palautetaan, jos löytyi; muuten palautetaan tyhjä.
	object find(const key& name) {
		iterator i = data.find(name);
		if (i == data.end()) {
			return T::null();
		}
		return i->second;
	}
	// Tyhjennys: vapautetaan ja poistetaan kaikki.
	void clear() {
		for (iterator i = data.begin(); i != data.end(); ++i) {
			T::free(i->second);
		}
		data.clear();
	}
	// Poisto nimen perusteella: etsitään, vapautetaan ja poistetaan.
	// Toisella parametrilla voi kieltää vapauttamisen, jos jostain syystä
	// haluaa vain ottaa arvon pois säilöstä ja huolehtia itse lopusta.
	bool erase(const std::string& key, bool free_data = true) {
		iterator i = data.find(key);
		if (i == data.end()) {
			return false;
		}
		if (free_data) {
			T::free(i->second);
		}
		data.erase(i);
		return true;
	}
	// Poisto datan perusteella: käydään listaa läpi, poistetaan osuma.
	// Toinen parametri sama kuin yllä.
	bool erase(object t, bool free_data = true) {
		for (iterator i = data.begin(); i != data.end(); ++i) {
			// Jos löytyi, vapautetaan ja poistetaan.
			if (i->second == t) {
				if (free_data) {
					T::free(i->second);
				}
				data.erase(i);
				return true;
			}
		}
		// Ei löytynyt.
		return false;
	}
	// Tuhoaja: tyhjennetään sisältö.
	~cache() {
		clear();
	}
};

// Varsinainen SDL-osuus alkaa tästä:

#include <SDL.h>
#ifdef USE_SDL_IMAGE
	// Tuki muillekin kuin BMP-kuville saadaan SDL_image-kirjastosta:
	#include <SDL_image.h>
#endif

// Toteutetaan SDL_Surface*-tyypille cache-mallin tarvitsema rakenne.
struct image_cache_data_type {
	// Tyyppi: SDL_Surface *.
	typedef SDL_Surface* type;

	// Vapautus: SDL_FreeSurface.
	static void free(type& t) {
		SDL_FreeSurface(t);
	}

	// Tyhjä arvo: 0-osoitin (NULL-osoitin).
	static type null() {
		return 0;
	}

	// Tyhjän tarkistus: vertailu nollaan.
	static bool is_null(type const& t) {
		return t == 0;
	}
};

// Tehdään mallista tämän tyypin avulla luokka kuville.
class image_cache: public cache<image_cache_data_type> {
	// Tätäkään ei kuulu kopioida, joten kopiomuodostin on yksityinen.
	image_cache(const image_cache& t): cache_type() {
		throw std::logic_error("image_cache(const image_cache& t)");
	}
public:
	// Muodostin on tyhjä.
	image_cache() {}

	// Latausfunktio: haetaan vanha kuva tai ladataan tiedostosta.
	SDL_Surface *get(const std::string& file) {
		// Etsitään vanhaa kuvaa, ja jos löytyi, palautetaan se.
		SDL_Surface *tmp = find(file);
		if (tmp) {
			return tmp;
		}
		// Ladataan kuva, ja jos epäonnistui, heitetään virhe.
		#ifdef USE_SDL_IMAGE
			// SDL_image-kirjastossa on tuki monelle formaatille.
			tmp = IMG_Load(file.c_str());
		#else
			tmp = SDL_LoadBMP(file.c_str());
		#endif
		if (!tmp) {
			throw std::runtime_error(SDL_GetError());
		}
		// Laitetaan kuva säilöön ja palautetaan se.
		data[file] = tmp;
		return tmp;
	}
	// Staattinen funktio, jossa on staattinen image_cache-olio.
	// Staattinen olio luodaan ohjelman alussa ja tuhotaan lopussa aivan
	// automaattisesti, ja olion tuhoajafunktiossa tuhotaan myös sen
	// sisältämät kuvat (~cache => clear => free => SDL_FreeSurface).
	// Funktio palauttaa viittauksen olioon, joten kaikki pääsevät
	// käyttämään samaa image_cache-oliota.
	static image_cache& common() {
		static image_cache c;
		return c;
	}
};

#endif

// Otetaan mukaan tämä image_cache-luokka.
#include "image_cache.hpp"

// Tarvitaan myös SDL:n otsikkotiedosto sekä pari standardikirjaston otsikkoa.
#include <SDL.h>
#include <cstdlib>
#include <stdexcept>
#include <string>
#include <iostream>

// SDL:n ruutu.
SDL_Surface *ruutu;

// Ohjelman toistuva toiminta.
bool ohjelma();

// Pääohjelma. Käytetään try-catch-rakennetta virheenkäsittelyyn.
int main(int argc, char **argv)
try {
	// SDL:n alustus ja tarvittaessa virheilmoitus.
	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
		throw std::runtime_error(std::string("SDL_Init: ") + SDL_GetError());
	}

	// Automatisoidaan SDL_Quit-funktion kutsuminen.
	std::atexit(SDL_Quit);

	// Luodaan kaksoispuskuroitu ikkuna.
	if ((ruutu = SDL_SetVideoMode(640, 480, 32, SDL_DOUBLEBUF)) == 0) {
		throw std::runtime_error(std::string("SDL_SetVideoMode: ") + SDL_GetError());
	}

	// Piilotetaan kursori.
	SDL_ShowCursor(SDL_DISABLE);

	// Ladataan kuvat. Täältä lentää automaattisesti virheilmoitus, jos
	// kuvia ei jostain syystä saada auki. Lataus ei välttämättä olisi
	// tarpeen, koska kuvat haetaan myöhemminkin samalla get-metodilla
	// ja siis myös ladataan tarvittaessa tiedostosta.
	image_cache::common().get("tausta.bmp");
	image_cache::common().get("hiiri.bmp");

	// Ajetaan ohjelmaa, kunnes se palauttaa falsen.
	while (ohjelma() == true);

	// Palautetaan 0.
	// SDL_Quit kutsutaan automaattisesti ohjelman lopussa.
	return 0;

} catch (std::exception& e) {
	// Virhetilanteessa tulostetaan virhe ja palautetaan virhekoodi.
	std::cerr << e.what() << std::endl;
	return 1;
}

// Ohjelman toistuva toiminta.
bool ohjelma() {
	// Käsitellään viestit jonosta.
	SDL_Event event;
	while (SDL_PollEvent(&event)) {
		// Painettiinko ruksia?
		if (event.type == SDL_QUIT) {
			return false;
		}
		if (event.type == SDL_KEYDOWN) switch (event.key.keysym.sym) {
			// Escape ja Q lopettavat.
			case SDLK_ESCAPE:
			case 'q':
				return false;

			// H poistaa hiiren muistista, T taustan ja K kaikki.
			// Seuraavalla piirtokerralla ne siis ladataan taas.
			// Jos kuvia on levyllä muokattu, esiin tulevat uudet.
			case 'h':
				image_cache::common().erase("hiiri.bmp");
				break;
			case 't':
				image_cache::common().erase("tausta.bmp");
				break;
			case 'k':
				image_cache::common().clear();
				break;
			default: break;
		}
	}
	// Piirretään ruudulle tausta ja hiiri.
	// Kuvat on ladattu aluksi main-funktiossa, joten nyt ne vain haetaan
	// ohjelman yhteisestä image_cache-oliosta (image_cache::common()),
	// ellei muistia ole tyhjennetty (ks. yllä).
	SDL_BlitSurface(image_cache::common().get("tausta.bmp"), 0, ruutu, 0);

	if (SDL_Surface *hiiri = image_cache::common().get("hiiri.bmp")) {
		SDL_SetColorKey(hiiri, SDL_SRCCOLORKEY, SDL_MapRGB(hiiri->format, 0xff, 0xff, 0xff));
		int x, y;
		SDL_GetMouseState(&x, &y);
		// Piirretään kuvan keskikohta kursorin paikalle.
		SDL_Rect r = {x - hiiri->w / 2, y - hiiri->h / 2};
		SDL_BlitSurface(hiiri, 0, ruutu, &r);
	}

	SDL_Flip(ruutu);
	return true;
}