{"id":5497,"date":"2012-01-24T13:58:46","date_gmt":"2012-01-24T19:58:46","guid":{"rendered":"http:\/\/bobbeaty.com\/wp\/?p=5497"},"modified":"2012-01-26T03:40:06","modified_gmt":"2012-01-26T09:40:06","slug":"firing-up-c-functors-beautiful-solution-to-the-problem","status":"publish","type":"post","link":"https:\/\/bobbeaty.com\/wp\/archives\/5497","title":{"rendered":"Firing Up C++ Functors – Beautiful Solution to the Problem"},"content":{"rendered":"

\"cplusplus.jpg\"<\/p>\n

This morning I've been battling a really nasty problem in my Greek Engine - at the start of the business day, I need to clear out the previous day's values for some daily summary values - like open\/high\/low. I do that fine in the instruments themselves, but there's an component in the engine that listens to all<\/em> trades and creates this summary data. And it wasn't<\/strong> getting cleared out. So when I reloaded all the instruments at the beginning of the day, and flushed all the messages from the exchanges to them, these \"lingering\" values from the previous day were slipping in.<\/p>\n

Ideally, we'd just clear out these values, and I could<\/em> just clear out the cache in the component. But then I'd loose the last valid trade as well - and that I don't<\/strong> want to loose. So I really to operate on all the messages in the component. This seemed to scream<\/em> \"Iterator!\" to me, and I spent several hours on it. The problem is not with the basic iterator concept, it's that we're trying to iterate over a trie<\/a>, and that's not really all that easy when your trie<\/a> is lockless, and it's possible for someone to change the data as soon as you're sure it's there.<\/p>\n

Yeah, it's nice to think of an iterator on the trie<\/a>, but it's not really all that practical.<\/p>\n

Sure didn't stop me from wasting several hours trying<\/em> to get it to work, though.<\/p>\n

What I really wanted was to be able to pass in<\/em> some function to operate on all the messages in the trie<\/a>, and then let the trie<\/a> itself, handle all the thread-safety issues. This seemed like a much better<\/em> idea, so I started looking into something I haven't used up till now - functors.<\/p>\n

The basic idea is just to have a simple class that has a few standard operators on it, and then use this base class to derive all the operations that you need. For example, in my case what I needed was to operate on Messages. Sure, I only needed to operate on one kind<\/em> of Message - the Summary Message, but if I'm going to make this, I might as well make it capable of dealing with all the message functor usage I'm going to need.<\/p>\n

So I create the following header:<\/p>\n

  namespace<\/span> msg\n  {<\/span>\n  struct<\/span> MessageFunction\n  {<\/span>\n    \/\/ this is the overt method that can be called<\/span>\n    bool<\/span> doIt(<\/span> Message *<\/span>aMsg )<\/span>;<\/span>\n    \/\/ \u2026and this is the simple operator to make it look like a function<\/span>\n    bool<\/span> operator(<\/span>)<\/span>(<\/span> Message *<\/span>aMsg )<\/span>;<\/span>\n \n    \/\/ these are the methods to override for the different message types<\/span>\n    virtual<\/span> bool<\/span> doHello(<\/span> message::<\/span>Hello<\/span> &<\/span> aMsg )<\/span>;<\/span>\n    virtual<\/span> bool<\/span> doGoodBye(<\/span> message::<\/span>GoodBye<\/span> &<\/span> aMsg )<\/span>;<\/span>\n    virtual<\/span> bool<\/span> doQuote(<\/span> message::<\/span>Quote<\/span> &<\/span> aMsg )<\/span>;<\/span>\n    virtual<\/span> bool<\/span> doPrint(<\/span> message::<\/span>Print<\/span> &<\/span> aMsg )<\/span>;<\/span>\n  }<\/span>;<\/span>\n  }<\/span>      \/\/ end of namespace msg<\/span><\/pre>\n
and I implemented all the specific message type methods so that if you don't need<\/em> to implement it, you don't have to, and it'll just be a no-op on the message:<\/p>\n
  namespace<\/span> msg\n  {<\/span>\n  \/\/ this is the overt method that can be called<\/span>\n  bool<\/span> MessageFunction::<\/span>doIt<\/span>(<\/span> Message *<\/span>aMsg )<\/span>\n  {<\/span>\n    bool<\/span>      error =<\/span> false<\/span>;<\/span>\n \n    if<\/span> (<\/span>aMsg !<\/span>=<\/span> NULL<\/span>)<\/span> {<\/span>\n      switch<\/span> (<\/span>aMsg-<\/span>><\/span>getType(<\/span>)<\/span>)<\/span> {<\/span>\n        case<\/span> eHello:<\/span>\n          error =<\/span> !<\/span>doHello(<\/span>(<\/span>message::<\/span>Hello<\/span> &<\/span>)<\/span>(<\/span>*<\/span>aMsg)<\/span>)<\/span>;<\/span>\n          break<\/span>;<\/span>\n        case<\/span> eGoodBye:<\/span>\n          error =<\/span> !<\/span>doGoodBye(<\/span>(<\/span>message::<\/span>GoodBye<\/span> &<\/span>)<\/span>(<\/span>*<\/span>aMsg)<\/span>)<\/span>;<\/span>\n          break<\/span>;<\/span>\n        case<\/span> eQuote:<\/span>\n          error =<\/span> !<\/span>doQuote(<\/span>(<\/span>message::<\/span>Quote<\/span> &<\/span>)<\/span>(<\/span>*<\/span>aMsg)<\/span>)<\/span>;<\/span>\n          break<\/span>;<\/span>\n        case<\/span> ePrint:<\/span>\n          error =<\/span> !<\/span>doPrint(<\/span>(<\/span>message::<\/span>Print<\/span> &<\/span>)<\/span>(<\/span>*<\/span>aMsg)<\/span>)<\/span>;<\/span>\n          break<\/span>;<\/span>\n        default<\/span>:<\/span>\n          error =<\/span> true<\/span>;<\/span>\n          break<\/span>;<\/span>\n      }<\/span>\n    }<\/span>\n \n    return<\/span> !<\/span>error;<\/span>\n  }<\/span>\n \n  \/\/ \u2026and this is the simple operator to make it look like a function<\/span>\n  bool<\/span> MessageFunction::<\/span>operator<\/span>(<\/span>)<\/span>(<\/span> Message *<\/span>aMsg )<\/span>\n  {<\/span>\n    return<\/span> doIt(<\/span>aMsg)<\/span>;<\/span>\n  }<\/span>\n \n  \/\/ these are the methods to override for the different message types<\/span>\n  bool<\/span> MessageFunction::<\/span>doHello<\/span>(<\/span> message::<\/span>Hello<\/span> &<\/span> aMsg )<\/span>\n  {<\/span>\n    return<\/span> true<\/span>;<\/span>\n  }<\/span>\n \n  bool<\/span> MessageFunction::<\/span>doGoodBye<\/span>(<\/span> message::<\/span>GoodBye<\/span> &<\/span> aMsg )<\/span>\n  {<\/span>\n    return<\/span> true<\/span>;<\/span>\n  }<\/span>\n \n  bool<\/span> MessageFunction::<\/span>doQuote<\/span>(<\/span> message::<\/span>Quote<\/span> &<\/span> aMsg )<\/span>\n  {<\/span>\n    return<\/span> true<\/span>;<\/span>\n  }<\/span>\n \n  bool<\/span> MessageFunction::<\/span>doPrint<\/span>(<\/span> message::<\/span>Print<\/span> &<\/span> aMsg )<\/span>\n  {<\/span>\n    return<\/span> true<\/span>;<\/span>\n  }<\/span>\n  }<\/span>      \/\/ end of namespace msg<\/span><\/pre>\n
Now in my code, I only needed to implement a subclass that did the one thing I needed it to do - reset the values. In this case, I'll use the Quote as an example:<\/p>\n
  struct<\/span> QuoteClear :<\/span>\n    MessageFunction\n  {<\/span>\n    virtual<\/span> bool<\/span> doQuote(<\/span> message::<\/span>Quote<\/span> &<\/span> aMsg )<\/span>;<\/span>\n  }<\/span>;<\/span><\/pre>\n
implemented as:<\/p>\n
  bool<\/span> QuoteClear::<\/span>doQuote<\/span>(<\/span> message::<\/span>Quote<\/span> &<\/span> aMsg )<\/span>\n  {<\/span>\n    aMsg.clear<\/span>(<\/span>)<\/span>;<\/span>\n    return<\/span> true<\/span>;<\/span>\n  }<\/span><\/pre>\n
Then all I needed to do was to add in an apply()<\/tt> method to the trie, and have it run through all the values and on each one that is non-NULL, call the functor. The signature for the apply()<\/tt> method is simple, and it makes it clear how to use it:<\/p>\n
  virtual<\/span> bool<\/span> apply(<\/span> MessageFunction &<\/span> aFunctor )<\/span>;<\/span><\/pre>\n
This was an excellent<\/em> use of the idea, as it allowed me to pass in an arbitrarily complex function to be operated on a general Message, and the apply()<\/tt> method simply knows how to scan it's internal data structure, and call this application as needed. Very sweet.<\/p>\n
While it's not as generally useful as an iterator on a trie, it's perfectly suited to what I needed. Love the idea.<\/p>\n","protected":false},"excerpt":{"rendered":"
This morning I’ve been battling a really nasty problem in my Greek Engine – at the start of the business day, I need to clear out the previous day’s values for some daily summary values – like open\/high\/low. I do that fine in the instruments themselves, but there’s an component in the engine that listens […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3,6],"tags":[],"class_list":["post-5497","post","type-post","status-publish","format-standard","hentry","category-coding","category-cube-life"],"_links":{"self":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts\/5497","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/comments?post=5497"}],"version-history":[{"count":4,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts\/5497\/revisions"}],"predecessor-version":[{"id":5510,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts\/5497\/revisions\/5510"}],"wp:attachment":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/media?parent=5497"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/categories?post=5497"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/tags?post=5497"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}