examples/inventory/inventory.H

#ifndef inventory_H
#define inventory_H

#include <x/obj.H>
#include <x/ref.H>
#include <x/ptr.H>
#include <x/uuid.H>
#include <x/fd.H>
#include <x/fditer.H>
#include <x/serialize.H>
#include <x/deserialize.H>
#include <x/exception.H>

#include <map>
#include <iostream>

// An inventory of stuff

class inventoryObj : virtual public x::obj {

public:

	// This is the inventory, key product name, int is the number in stock.

	std::map<std::string, int> stock;

	// uuid of this object in the repository

	x::uuid uuid;

	// Default constructor

	inventoryObj() {}

	// Destructor
	~inventoryObj() {}

	// Copy constructor
	inventoryObj(const inventoryObj &o) : stock(o.stock), uuid(o.uuid)
	{
	}

	// Serialization function

	template<typename iter_type>
	void serialize(iter_type &iter)
	{
		iter(stock);
	}

	// Construct from an object in the repository

	inventoryObj(const x::uuid &uuidArg, const x::fd &fd) : uuid(uuidArg)
	{
		x::fdinputiter b(fd), e;

		x::deserialize::iterator<x::fdinputiter> iter(b, e);

		serialize(iter);
	}

	// The above constructor threw an exception, so the manager calls this
	// one. We should report an error somehow, the inventory object must be
	// corrupted, but this is just an example.

	inventoryObj(const x::uuid &uuidArg) : uuid(uuidArg)
	{
	}
};

typedef x::ref<inventoryObj> inventory;

typedef x::ptr<inventoryObj> inventoryptr;
#endif

examples/inventory/setinventory.C

#include <stasher/client.H>
#include "inventory.H"

#include <sstream>
#include <iterator>

std::string apply_updates(const inventory &i,
			  int argc, char **argv);

void setinventory(int argc, char **argv)
{
	if (argc < 2)
		return;

	auto client=stasher::client::base::connect();

	stasher::client::base::transaction tran=
		stasher::client::base::transaction::create();

	// Get the existing object, if it exists, first.

	stasher::client::base::getreq req
		=stasher::client::base::getreq::create();

	req->openobjects=true;
	req->objects.insert(argv[1]);

	stasher::contents contents=client->get(req)->objects;

	if (!contents->succeeded)
		throw EXCEPTION(contents->errmsg);

	auto existing=contents->find(argv[1]);

	if (existing == contents->end())
	{
		// Object did not exist, create a new one.

		std::string i=apply_updates(inventory::create(), argc, argv);

		if (i.empty())
			return; // New one is empty, nothing to do

		tran->newobj(argv[1], i);
	}
	else
	{
		// Update an existing object.
		auto i=apply_updates(inventory::create(existing->second.uuid,
						       existing->second.fd),
				     argc, argv);

		// If there's no inventory at all, delete it, else update it.
		if (i.empty())
			tran->delobj(argv[1], existing->second.uuid);
		else
			tran->updobj(argv[1],
				     existing->second.uuid, i);
	}

	// Note that this is a basic, simple example, that doesn't check for
	// req_rejected_stat, so if two updates occur at the same time, one
	// is going to get tossed out. This program is for demo purposes only.
	stasher::putresults results=client->put(tran);

	if (results->status != stasher::req_processed_stat)
		throw EXCEPTION(x::tostring(results->status));

	std::cout << "Updated" << std::endl;
}

// Apply updates to the inventory in an existing object.

std::string apply_updates(const inventory &i,
			  int argc, char **argv)
{
	for (int n=2; n+1<argc; n += 2)
	{
		int count=0;

		std::istringstream(argv[n+1]) >> count;

		std::string name(argv[n]);

		if (count == 0)
			i->stock.erase(name);
		else
			i->stock[name]=count;
	}

	// Now, serialize it into a string.

	std::string buf;

	if (i->stock.empty())
		return buf; // Empty inventory, return an empty string.

	typedef std::back_insert_iterator<std::string> ins_buf_iter_t;

	ins_buf_iter_t iter(buf);

	x::serialize::iterator<ins_buf_iter_t> serialize(iter);

	i->serialize(serialize);

	return buf;
}

int main(int argc, char **argv)
{
	try {
		setinventory(argc, argv);
	} catch (const x::exception &e)
	{
		std::cerr << e << std::endl;
		return 1;
	}
	return 0;
}