Ebenezer Enterprises

We host a code generator called the C++ Middleware Writer (CMW). The CMW writes portable binary serialization code.

Supported types and platforms
Github repo with example code

Provide feedback
Company overview
Comparing the serialization library in Boost to our approach
Links

The CMW is the back tier of a 3-tier system:

  1. CMW (server) (back tier)
  2. cmwA (server) (middle tier) (cmwA is short for CMW Ambassador)
  3. genz (runs and exits) (front tier)

The middle and front tiers are needed in order to use the CMW. A C++ 2017 compiler is needed to build the software.

An account is needed to use the CMW. To get an account send an email to support@webEbenezer.net and include a password between 10 and 50 characters long for your account. We'll reply by giving you an account number. After receiving your account number, update your cmwA.cfg file accordingly.

Links to some files in the archive:
Readme
middle_back.mdl -- Middle file that specifies what to generate.
zz.middle_back.hh -- CMW output based on middle_back.mdl.

Why use a 3-tier architecture?

Originally we used a 2-tier system. We switched to a 3-tier architecture for performance, network administrative and security reasons. In the 2-tier architecture, the front tier had to establish a TCP connection to the back tier each time it ran. In the 3-tier architecture, the middle tier keeps a TCP connection with the CMW and uses it to serve front tier instances.

In the 2-tier architecture, every user had to be given permission to get through your firewall in order to communicate with the CMW. With the 3-tier architecture, all requests are mediated by the cmwA so only the machine the cmwA is running on needs attention from a network administrator.

Recent Developments

August, 2017
I used this benchmark to test the CMW against other libraries. The CMW produced a smaller serialized size than Capnproto or Cereal:
Capnproto 17,768
Cereal    17,416
CMW       16,712 
The CMW-based approach was also faster than Cereal in this benchmark.
April, 2017
CMW version 1.14 is here. This version adds support for plf::colony, std::string_view and boost::container::small_vector.

There's also support for a no_inline option in the Middle code. For example:

  -out -no_inline (bool, ::std::string_view)
This option indicates that a generated function should not be marked as inline. If you only include a generated header in one translation unit, it's safe to use no_inline. This option may help reduce the size of your executable.

Fixed a number of things, some of which are documented in the repo.

August, 2014
Version 1.13 of the CMW is on line. This version takes advantage of move semantics. Here's an example of some generated code:
template <class R>
void Give (::cmw::ReceiveBuffer<R>& buf
       ,std::vector<std::deque<std::string> >& az1){
  int32_t count[2];
  count[0]=Give<uint32_t>(buf);
  az1.reserve(az1.size()+count[0]);
  for(;count[0]>0;--count[0]){
    std::deque<std::string> rep2;
    count[1]=Give<uint32_t>(buf);
    for(;count[1]>0;--count[1]){
      rep2.emplace_back(buf.GiveString());
    }
    az1.emplace_back(::std::move(rep2));
  }
}
December, 2013
Version 1.12 of the CMW released.
April, 2012
Version 1.11 of the CMW released.
November, 2010
Version 1.10 of the CMW released.