stupid::Object
    thing;
  

// Initialize the object
thing.write().commit_new(...);

// That's equivalent to doing this
thing.write().commit(new Thing{...});

// Create a copy of the object to modify
auto copy = thing.write().copy();

copy->modify();
copy->the();
copy->object();

// Commit the modified object
thing.write().commit(copy);

// Get a reference to the most recently committed version of the object
stupid::Immutable
    ref = thing.read().get();

ref->
   access();
ref->
   read_only();
ref->
   stuff();


   // stupid::Immutable is a reference counted type. The referenced version of

   // the object will remain valid as long as there are references to it, even

   // if the writer thread commits new versions of the object.

  

struct
{
	stupid::SyncSignal signal;
	stupid::SignalSyncObject
    data;
	
	
   Sync() : data(signal) {}
} sync;
  

void update_audio_data()
{
	auto copy = sync.data.copy();

	copy->modify();
	copy->the();
	copy->data();
	
	sync.data.commit(copy);
}

void audio_callback(...)
{
	// stupid::SyncSignal::operator() is called once at the start
	// of each audio buffer, and nowhere else.

	// This increments its value by 1.

	// The signal's value is checked whenever
	// stupid::SignalSyncObject::get_data() is called.
	sync.signal();

	...

	// stupid::SignalSyncObject::get_data() is guaranteed to always
	// return a reference to the same data unless:
	//  1. there is new data available, AND
	//  2. the current signal value is greater than the previous
	//     call to get_data().

	// Therefore new data (if there is any) is only retrieved on
	// the first call to get_data() per audio buffer.
	const AudioData& data1 = sync.data.get_data();
	
	data1.use();
	data1.the();
	data1.data();

	/**** UI thread could write new data here, for example ****/
	
	const auto& data2 = sync.data.get_data();
	
	// Will always pass. If new data was written by the UI thread
	// then it won't be picked up until the next audio buffer.
	assert(&data1 == &data2);
}

struct
{
	stupid::AtomicTrigger start_playback;
	stupid::AtomicTrigger stop_playback;
} sync;

void process_ui_events()
{
	if (start_button_pressed)
	{
		sync.start_playback(); // Tell the audio thread to start playback ASAP
	}
	
	if (stop_button_pressed)
	{
		sync.stop_playback(); // Tell the audio thread to stop playback ASAP
	}
}

void audio_process()
{
	switch (current_state)
	{
		case Playing:
		{
			if (sync.stop_playback) stop();
			break;
		}
		
		case Stopped:
		{
			if (sync.start_playback) start();
			break;
		}
	}
}