Bibliothèque de gestion d'inventaire

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#ifndef INVENTORY_HEADER_INCLUDED 
#define INVENTORY_HEADER_INCLUDED 1 
  
#include <map> 
#include <stdexcept> 
  
namespace inventory { 
  
template <typename Item, typename Size = long> 
class inventory { 
public: 
	typedef Size size_type; 
	typedef Item item; 
  
private: 
	typedef std::map<item, size_type> internals_type; 
	internals_type internals; 
	size_type full_size; 
  
public: 
	typedef typename internals_type::const_iterator const_iterator; 
  
public: 
	/* 
	creates an empty inventory 
	*/ 
	inventory() : full_size(0) {} 
  
	/* 
	adds one or more items 
	returns the number of this item kind after addition. 
	throws std::invalid_argument if count is negative 
	*/ 
	size_type add(item const& that, size_type count = 1) { 
		if (count<0) throw std::invalid_argument("can't add negative element count"); 
		full_size+=count; 
		return internals[that] += count; 
	} 
  
	/* 
	removes one or more items. 
	returns true if remove was successful, false if there were not enough items 
	throws std::invalid_argument if count is negative 
	*/ 
	bool remove(item const& that, size_type count = 1) { 
		if (count<0) throw std::invalid_argument("can't remove negative element count"); 
  
		//no need to run search if 0. 
		if (count==0) return true; 
  
		auto where = internals.find(that); 
		if (where == internals.end() || where->second < count) { 
			return false; 
		} 
		full_size-=count; 
		where->second -= count; 
		return true; 
	} 
  
	/* 
	gives the number of items in this inventory 
	*/ 
	size_type size() const {return full_size;} 
  
	/* 
	gives the number of item kinds 
	*/ 
	size_type distinct() const {return internals.size();} 
  
	/* 
	gives the count of a specific item in this inventory. 
	*/ 
	size_type count(item const& that) const { 
		auto where = internals.find(that); 
		return (where != internals.end()) ? where->second : 0; 
	} 
  
	const_iterator begin() const {return internals.begin();} 
	const_iterator end() const {return internals.end();} 
}; 
  
}//inventory:: 
  
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <string> 
  
#include <iostream> 
#include <iomanip> 
  
#include "inventory.hpp" 
  
template <typename Item, typename Size> 
std::ostream& operator<<(std::ostream& os, inventory::inventory<Item, Size> const& i) { 
	os << std::right; 
	for(auto const& content : i) { 
		os << std::setw(8) << content.second << " x " << content.first << '\n'; 
	} 
	return os << "------------\ntotal :\t" << i.size() << " éléments"; 
} 
  
typedef std::string item; 
int main() { 
	const item cle = "clé à molette"; 
  
	inventory::inventory<item> inventaire; 
	inventaire.add(cle, 4); 
	std::cout << "Inventaire initial:\n" << inventaire << std::endl; 
  
	const int n = 2; 
	std::cout << "Utilisation de " << n << " clés" << std::endl; 
  
	inventaire.remove(cle, n); 
	inventaire.add("morceau d'acier tordu", n); 
	std::cout << "Inventaire:\n" << inventaire << std::endl; 
  
  
	try { 
		std::cout << "Tentative de retirer -2 clés." << std::endl; 
		const bool reussite = inventaire.remove(cle, -2); 
		std::cout << "Ce fut accepté, " << (reussite ? "et réalisé!" : "mais pas réalisé.")<< std::endl; 
	} catch (std::invalid_argument const& e) { 
		std::cerr << "Impossible! D'ailleurs je suis curieux de voir -2 clés posées sur une table." << std::endl; 
	} 
  
	return 0; 
}