For a little while now I've had notifications from gaug.es that a number of inbound links were getting HTTP 404 errors. This all stemmed from the fact that I reassigned this domain from a Tumblog (still accessible at tumblr.alanquatermain.me, btw) and ported all the relevant (i.e. longer-form) posts across from that source. There were still a few links out there which were pointing to the old Tumblr articles, though, which no longer worked.

What to do?

In updating some stuff for the Readium SDK project, I wanted to use std::shared_ptr in some containers without lots of typing. Essentially I wanted something like shared_vector<SomeType> to magically unfold into vector<shared_ptr<SomeType>>.

Since I'm using C++11 for the project, that's actually pretty easy to do through the magic of template aliases:

template <class _Tp>
using shared_vector = std::vector<std::shared_ptr<_Tp>>;
 
template <class _Tp>
using shared_list = std::list<std::shared_ptr<_Tp>>;

Sadly, Microsoft's C++ compiler in Visual Studio 2012 doesn't support this syntax just yet, so I had to drop back to the C++03 implementation for that platform:

template <class _Tp>
class shared_vector : public std::vector<std::shared_ptr<_Tp>>
{
    typedef std::vector<std::shared_ptr<_Tp>>   _Base;
 
public:
    shared_vector() _NOEXCEPT_(std::is_nothrow_default_constructible<typename _Base::allocator_type>::value) : _Base() {}
    explicit shared_vector(const typename _Base::allocator_type& __alloc) : _Base(__alloc) {}
    explicit shared_vector(typename _Base::size_type __n) : _Base(__n) {}
    shared_vector(typename _Base::size_type __n, const typename _Base::value_type& __v, const typename _Base::allocator_type& __a = typename _Base::allocator_type()) : _Base(__n, __v, __a) {}
    template <class _InputIterator>
    shared_vector(_InputIterator __f, _InputIterator __l, const typename _Base::allocator_type& __a = typename _Base::allocator_type()) : _Base(__f, __l, __a) {}
    shared_vector(const shared_vector& __o) : _Base(__o) {}
    shared_vector(shared_vector&& __o) : _Base(std::move(__o)) {}
#if EPUB_COMPILER_SUPPORTS(CXX_INITIALIZER_LISTS)
    shared_vector(std::initializer_list<typename _Base::value_type> __il) : _Base(__il) {}
    shared_vector(std::initializer_list<typename _Base::value_type> __il, const typename _Base::allocator_type& __a) : _Base(__il, __a) {}
#endif
    ~shared_vector() { ~_Base(); }
 
    shared_vector& operator=(const shared_vector& __o) { _Base::operator=(__o); return *this; }
    shared_vector& operator=(shared_vector&& __o) { _Base::operator=(std::move(__o)); return *this; }
};
 
template <class _Tp>
class shared_list : public std::list<std::shared_ptr<_Tp>>
{
    typedef std::list<std::shared_ptr<_Tp>>     _Base;
 
public:
    shared_list() _NOEXCEPT_(std::is_nothrow_default_constructible<typename _Base::value_type>::value) : _Base() {}
    explicit shared_list(const typename _Base::allocator_type& __a) : _Base(__a) {}
    explicit shared_list(typename _Base::size_type __n) : _Base(__n) {}
    shared_list(typename _Base::size_type __n, const typename _Base::value_type& __v) : _Base(__n, __v) {}
    shared_list(typename _Base::size_type __n, const typename _Base::value_type& __v, const typename _Base::allocator_type& __a) : _Base(__n, __v, __a) {}
    template <class _Iter>
    shared_list(_Iter __f, _Iter __l) : _Base(__f, __l) {}
    template <class _Iter>
    shared_list(_Iter __f, _Iter __l, const typename _Base::allocator_type& __a) : _Base(__f, __l, __a) {}
    shared_list(const shared_list& __o) : _Base(__o) {}
    shared_list(shared_list&& __o) : _Base(std::move(__o)) {}
#if EPUB_COMPILER_SUPPORTS(CXX_INITIALIZER_LISTS)
    shared_list(std::initializer_list<typename _Base::value_type> __il) : _Base(__il) {}
    shared_list(std::initializer_list<typename _Base::value_type> __il, const typename _Base::allocator_type& __a) : _Base(__il, __a) {}
#endif
    ~shared_list() { ~_Base(); }
 
    shared_list& operator=(const shared_list& __o) { _Base::operator=(__o); return *this; }
    shared_list& operator=(shared_list&& __o) { _Base::operator=(std::move(__o)); return *this; }
};

C++11 wins so hard it's not even funny.

Something great begins today…

Well, actually it started a few months ago. Or maybe a year ago.

Perhaps it started in February 2012, when the IDPF started an initiative to create an open source reference implementation of an EPUB® 3 reading system. This was given the name ‘Readium’, and it was implemented in JavaScript as a Chrome browser extension. A lot of companies were involved with this effort, although the primary architects were the folks at Evident Point in Vancouver, BC. Along the way, the folks at ACCESS began contributing some major changes into the WebKit browser to provide significantly better typography for Japanese text.

When I started reading about XML back in 1998 I couldn't have imagined this would ever come to pass, but it has: I'm now a member of the W3C working groups on XML Security and CSS.

As a result, I've published an Objective-C library with an implementation of Canonicalized XML 2.0. I'm also looking forward to working alongside Daniel Glazman in getting CSS Paged Media up and running.

I think this is going to be a lot of fun…

A couple of days ago (on my birthday, no less!) I had the honour of moderating a session at the inaugural W3C and IDPF workshop on eBooks and the Open Web Platform, “eBooks: Great Expectations for Web Standards.” Due to a little something I wrote a while ago, I was asked to provide a position paper to the conference which naturally I was quite happy to do. One thing led to another, and there I was on Tuesday in New York, talking about DRM technology in a workshop hosted by O'Reilly, one of the most ardently anti-DRM companies you might name.

…not exactly a situation I'd anticipated when I started this job, certainly.

I decided to focus on the technology components behind such a system and the relevant standards, including their adoption and how user benefits can be built from the same components traditionally used to implement restrictions. I think, from discussions which took place later on, that I was broadly successful in achieving my aims; time will tell, I'm sure, if that impression is correct.

The slides and notes from my presentation are available from the W3C; here I'll go into some more detail on the topics I covered and some of the other output from the session. You can also find minutes from both days of the conference from the workshop's agenda page– here are direct links from day one and from day two.

All in all, it was fantastic to be involved, and I'm extremely thankful to the chairs and hosts for letting me be a part of it.

I've been asked a number of times to provide some examples on how to make use of AQXMLParser. A question which came in today has prompted me to make the effort and actually put together a simple project which demonstrates its use, along with its companion classes HTTPMessage and AQGzipInputStream.

The example project uses the asynchronous xml parser API to fetch my basic Tumblr post list, and displays the types and slugs of those posts in the UI (although it actually records all the data, in case some enterprising soul wants to actually make a detail view).

It fetches the data using a fairly simple set of code. I originally had it using a gzip stream, but it seems Tumblr never gzips its responses, so that didn't work out. I've left the appropriate code in there, albeit commented out, for your edification. In the snippets below, however, I've reinstated the gzip code.