C++11<\/em>. These extra bindings can always be layered on top of the “generic” C++ bindings, while reversing the process may be more difficult.<\/p>\nThe result was a set of bindings that exposed the following semantics:<\/p>\n
Command Objects<\/h5>\n
All commands inherit from a Command object; e.g:<\/p>\n
class Command { };<\/span><\/p>\nAll key commands (i.e. set, get, delete) inherit from a KeyCommand<\/em> object which derives from Command<\/em>. The KeyCommand<\/em> object has accessors for key and hashkey, e.g.<\/p>\n\n
\u00a0<\/div>\n
class<\/span> KeyCommand :<\/span> public<\/span> Command {<\/span>
\n\u00a0 \u00a0 virtual<\/span> void<\/span> setKey(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span>)<\/span> =<\/span> 0<\/span>;<\/span>
\n\u00a0 \u00a0 virtual<\/span> void<\/span> setHashKey(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span>)<\/span> =<\/span> 0<\/span>;<\/span>
\n}<\/span><\/div>\n<\/div>\nThree template classes were created to aid with the construction of the command objects. They are instantiated with their T being the C libcouchbase structure which they wrap as their only data member – – and thus ensuring that the performance and memory profile of the C++ command class is more or less the same as the C struct (though there is a vtable). These templates provide common setters for commands which accept CAS and\/or an expiration time, e.g.<\/p>\n
\n
\u00a0<\/div>\n
template<\/span> <<\/span>typename<\/span> T><\/span> KeyCommand_v0 {<\/span>
\npublic<\/span>:<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0void<\/span> setKey(<\/span>const<\/span> std::<\/span>string<\/span> &<\/span>s)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0cmd.v<\/span>.v0<\/span>.key<\/span> =<\/span> s.c_str<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0cmd.v<\/span>.v0<\/span>.nkey<\/span> =<\/span> s.size<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 }<\/span>
\n\u00a0 \u00a0 \u00a0 \/\/ …<\/span>
\nprivate<\/span>:<\/span>
\n\u00a0 \u00a0 T cmd;<\/span>
\n}<\/span>;<\/span><\/div>\n<\/div>\nResponse Objects<\/h5>\n
Like command objects, the response objects too are provided in a hierarchy; they contain the C lcb_resp_t * as their only data member. Their hierarchy is as follows:<\/p>\n
\n- The abstract ResponseBase<\/em> class. This features accessors for keys<\/li>\n
- The abstract CasResponseBase<\/em> class which inherits ResponseBase<\/em> and provides accessors for the CAS<\/li>\n
- The Response<\/em> class which implements ResponseBase retrieving the key information from T::v.v0.key<\/li>\n
- The CasResponse <\/em>which inherits from Response<\/em> and implements CasResponseBase by providing cas via T::v.v0.cas<\/em><\/li>\n
- Response-specific classes which provide extra information; e.g. GetResponse<\/em> is implemented as CasResponse<\/em> with additional accessors for the value and flags.<\/li>\n<\/ol>\n
In the header, this looks something like this:<\/p>\n
\n
\u00a0<\/div>\n
class<\/span> ResponseBase {<\/span>
\npublic<\/span>:<\/span>
\n\u00a0 \u00a0 virtual<\/span> const<\/span> void<\/span> *<\/span>getKey(<\/span>lcb_size_t *<\/span>n)<\/span> const<\/span> =<\/span> 0<\/span>;<\/span>
\n\u00a0 \u00a0 std::<\/span>string<\/span> getKey(<\/span>)<\/span> const<\/span>;<\/span>
\n}<\/span>;<\/span><\/div>\n<\/div>\n\n
\n
template<\/span> <<\/span>typename<\/span> T, class<\/span> I><\/span>
\nclass<\/span> Response :<\/span> public<\/span> I {<\/span>
\npublic<\/span>:<\/span>
\n\u00a0 \u00a0 typedef<\/span> T LcbInternalResponse;<\/span>
\n\u00a0 \u00a0 virtual<\/span> const<\/span> void<\/span> *<\/span> getKey(<\/span>lcb_size_t *<\/span>n)<\/span> const<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 *<\/span>n =<\/span> resp–<\/span>><\/span>v.v0<\/span>.nkey<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 return<\/span> resp–<\/span>><\/span>v.v0<\/span>.key<\/span>;<\/span>
\n\u00a0 \u00a0 }<\/span>
\nprotected<\/span>:<\/span>
\n\u00a0 \u00a0 const<\/span> T *<\/span> resp;<\/span>
\n}<\/span>;<\/span><\/div>\n<\/div>\n<\/div>\n\n
\n
template<\/span> <<\/span>typename<\/span> T><\/span>
\nclass<\/span> CasResponse :<\/span> public<\/span> Response<<\/span>T, CasResponseBase><\/span>
\n{<\/span>
\npublic<\/span>:<\/span>
\n\u00a0 \u00a0 virtual<\/span> lcb_cas_t getCas(<\/span>)<\/span> const<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 return<\/span> Response<<\/span>T,CasResponseBase><\/span>::<\/span>getRawResponse<\/span>(<\/span>)<\/span>–<\/span>><\/span>v.v0<\/span>.cas<\/span>;<\/span>
\n\u00a0 \u00a0 }<\/span>
\n}<\/span>;<\/span><\/div>\n<\/div>\n\u00a0<\/div>\n
\n
\n
class<\/span> ArithmeticResponse :<\/span> public<\/span> CasResponse<<\/span>C_ArithResp><\/span> {<\/span>
\npublic<\/span>:<\/span>
\n\u00a0 \u00a0 lcb_uint64_t getValue(<\/span>)<\/span> const<\/span> {<\/span> return<\/span> getRawResponse(<\/span>)<\/span>–<\/span>><\/span>v.v0<\/span>.value<\/span>;<\/span> }<\/span>
\n}<\/span>;<\/span><\/div>\n<\/div>\n\u00a0<\/div>\n<\/div>\n
\u00a0<\/div>\n<\/div>\n
Since the response classes are both derived from the templates as well as their pure abstract bases, they can have their common members treated by helper methods and classes, so for example, for a given function called logKey which logs the key from the response, it may be implemented like so:<\/p>\n
\n
\u00a0<\/div>\n
void<\/span> logKey(<\/span>ResponseBase *<\/span>resp)<\/span> {<\/span>
\n\u00a0 \u00a0std::<\/span>cout<\/span> <<<\/span> resp–<\/span>><\/span>getKey(<\/span>)<\/span> <<<\/span> std::<\/span>