Ebenezer Enterprises

We host a code generator called the C++ Middleware Writer (CMW). The CMW writes portable, binary serialization code. A compiler with 2017 C++ support is needed to use the CMW.

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

  • CMW (server) (back tier)
  • cmwA (server) (middle tier) (cmwA is short for CMW Ambassador)
  • genz (ephemeral) (front tier)

The middle and front tiers are needed in order to use the CMW.

An account is needed to use the CMW. To get an account send an email to support@webEbenezer.net with "CMW account" as the subject. After receiving your account number, update your cmwA.cfg file accordingly.

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

Supported Types

Fundamental Types
bool, float, double, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t
Standard Library Types
array, complex, deque, list, (multi)map, (multi)set, span, string, string_view,
unique_ptr, unordered_(multi)map, unordered_(multi)set, vector
Boost Types
base_collection
ilist
multi_index_container
rbtree
small_vector  
Other Types
plf::colony
MarshallingInt -- a variable-length integer that is marshalled as one to five bytes depending on its value

User Defined Types
We don't support nested classes
We will consider supporting additional types if something you need isn't listed here.

Supported Platforms

The software has been tested on FreeBSD, Linux, Windows and Mac OS X.

Why use a 3-tier architecture?

Originally we used a 2-tier system. We switched to a 3-tier architecture for performance, administrative and security reasons. In the 2-tier architecture, the front tier had to establish a network connection to the back tier each time it ran. In the 3-tier architecture, the middle tier holds a 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, requests are mediated by the cmwA so only one machine needs attention from a network administrator.

Recent Developments

June, 2021
Got continuous integration working on the repo.
October, 2019
There have been a lot of changes that can be viewed in the repo, including using SCTP rather than TCP between the back and middle tiers.
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 an inLine option in the Middle code.

Bug fixes.

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& buf
         ,::std::vector<::std::deque<::std::string>>& a){
  for(::int32_t ca=give<::uint32_t>(buf);ca>0;--ca){
    ::std::deque<::std::string> v1;
    for(::int32_t cv1=give<::uint32_t>(buf);cv1>0;--cv1){
      v1.emplace_back(buf.giveStringView());
    }
    a.push_back(::std::move(v1));
  }
}

Github repo with example code

support@webEbenezer.net

Please send your questions and feedback to us.

Company overview
Links