Merge lp:~tes/dccl/3.0-codec-groups into lp:~dccl-dev/dccl/3.0

[toby schneider]

Two blueprints implemented:

1. http://gobysoft.org/wiki/DcclCodecGroups
These changes allow a user to change the codec name that is used for every field in an entire message with a single DCCLMessageOption. In addition, it defines an integer for the codec_version = N that resolves to a codec_group of "dccl.defaultN". This allows us to write new codecs for version 3 that fix bugs, improve functionality from version 2 while preserving backwards compatibility (since codec_version defaults to 2, the first version of Goby/DCCL that used Google Protobuf).

2. http://gobysoft.org/wiki/DcclImproveDefaultCodecs
These changes build on the codec_version defined in 1. to fix bugs and improve the efficiency of the DefaultMessageCodec and all the "repeated" field codecs that rely on the FieldCodecBase implementation (i.e. repeated calls of the singular encode/decode).

The links above go into more detail regarding the changes.

[lp:~tes/dccl/3.0-codec-groups]

315. By toby schneider on 2014-05-14

Added exports for additional dccl libraries (ccl and arithmetic)

316. By toby schneider on 2014-05-16

Fixed export install location

317. By toby schneider on 2014-05-22

Added logging of size of each field to dlog

318. By toby schneider on 2014-05-22

1. Add vector size for repeated fields when reporting size during encode, 2. Restore setfill after timestamp formatting for logger

319. By toby schneider on 2014-07-02

Added b64_encode and b64_decode helper functions that are similar to their hex_* equivalents; Added 'loaded()' method to Codec to allow a user to see all the loaded DCCL messages

320. By toby schneider on 2014-08-25

Changed default string codec in v3 to use a length prefix that is sized based on max_length (not fixed to 8 bits)

321. By toby schneider on 2014-08-27

Added warning for users who don't specify (dccl.msg).codec_version to encourage use of the DCCL3 defaults: option (dccl.msg).codec_version=3

[Chris Murphy (chrismurf-bluefin)]

  Per our discussion yesterday, this seems like a reasonable approach. We discussed a few ideas that may or may not make it into the final:

1. Add a deprecation warning for people who are implicitly relying on DCCL2 behavior.
2. Allow codec groups to fall back on the standard codecs by default, so a Bluefin codec library could consist of the standard DCCL3 Codecs... "plus X".
3. Change codec group to codec library (I don't care)
4. More documentation

None of these are major or blockers.

review: Approve

[toby schneider (tes)]

The deprecation warning (1.) is included in this merge.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-06 17:25:02 +0000
+++ CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -72,7 +72,7 @@
 install(DIRECTORY ${dccl_INC_DIR}/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include
   FILES_MATCHING PATTERN  "*.h" PATTERN "*.proto" PATTERN "test*" EXCLUDE)
 
-install(EXPORT dccl-config DESTINATION share/${PROJECTNAME}/cmake)
+install(EXPORT dccl-config DESTINATION share/dccl/cmake)
 
 ## let cmake know where the headers are
 include_directories(${dccl_INC_DIR})
@@ -132,10 +132,8 @@
   include_directories(${Cryptopp_INCLUDE_DIRS})
 endif()
 
+
 ## start adding subdirectories
 add_subdirectory(src)
 
-## export a file for folks to use
-export(TARGETS dccl FILE ${CMAKE_BINARY_DIR}/dccl-config.cmake)
-file(APPEND ${CMAKE_BINARY_DIR}/dccl-config.cmake "set(DCCL_INCLUDE_DIR \"${dccl_INC_DIR}\")")
 

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-01-08 22:30:52 +0000
+++ src/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -10,9 +10,12 @@
   codec.cpp
   field_codec.cpp
   field_codec_message_stack.cpp
-  field_codec_default.cpp
-  field_codec_default_message.cpp
   field_codec_manager.cpp
+  field_codec_id.cpp
+  codecs2/field_codec_default.cpp
+  codecs2/field_codec_default_message.cpp
+  codecs3/field_codec_default_message.cpp
+  codecs3/field_codec_default.cpp
   type_helper.cpp
   bitset.cpp
   dynamic_protobuf_manager.cpp
@@ -32,14 +35,21 @@
 option(build_arithmetic "Build arithmetic coders shared library" ON)
 option(build_ccl "Build Compact Control Language (CCL) legacy support shared library" ON)
 
+set(DCCL_EXPORT_TARGETS dccl)
+
 if(build_ccl)
   add_subdirectory(ccl)
+  set(DCCL_EXPORT_TARGETS ${DCCL_EXPORT_TARGETS} dccl_ccl_compat)
 endif()
 
 if(build_arithmetic)
   add_subdirectory(arithmetic)
+  set(DCCL_EXPORT_TARGETS ${DCCL_EXPORT_TARGETS} dccl_arithmetic)
 endif()
 
+export(TARGETS ${DCCL_EXPORT_TARGETS} FILE ${CMAKE_BINARY_DIR}/dccl-config.cmake)
+file(APPEND ${CMAKE_BINARY_DIR}/dccl-config.cmake "set(DCCL_INCLUDE_DIR \"${dccl_INC_DIR}\")")
+
 if(enable_testing)
   add_subdirectory(test)
 endif()

=== modified file 'src/apps/dccl/dccl_tool.cpp'
--- src/apps/dccl/dccl_tool.cpp	2014-04-22 20:08:20 +0000
+++ src/apps/dccl/dccl_tool.cpp	2014-08-27 16:27:22 +0000
@@ -26,6 +26,8 @@
 
 
 #include <sstream>
+#include <fstream>
+
 
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/text_format.h>
@@ -40,13 +42,16 @@
 #include "dccl_tool.pb.h"
 
 enum Action { NO_ACTION, ENCODE, DECODE, ANALYZE, DISP_PROTO };
-enum Format { TEXTFORMAT, HEX, BASE64 };
+enum Format { BINARY, TEXTFORMAT, HEX, BASE64 };
 
 struct Config
 {
     Config()
         : action(NO_ACTION),
-          format(HEX)
+          format(BINARY),
+          id_codec(dccl::Codec::default_id_codec_name()),
+          verbose(false),
+          omit_prefix(false)
         { }
     
     Action action;
@@ -55,11 +60,14 @@
     std::set<std::string> message;
     std::set<std::string> proto_file;
     Format format;
+    std::string id_codec;
+    bool verbose;
+    bool omit_prefix;
 };
 
     
 void analyze(dccl::Codec& dccl, const Config& cfg);
-void encode(dccl::Codec& dccl, const Config& cfg);
+void encode(dccl::Codec& dccl, Config& cfg);
 void decode(dccl::Codec& dccl, const Config& cfg);
 void disp_proto(dccl::Codec& dccl, const Config& cfg);
 
@@ -67,67 +75,95 @@
 void load_desc(dccl::Codec* dccl,  const google::protobuf::Descriptor* desc, const std::string& name);
 void parse_options(int argc, char* argv[], Config* cfg);
 
+
 int main(int argc, char* argv[])
 {
-    Config cfg;
-    parse_options(argc, argv, &cfg);
-
-    dccl::dlog.connect(dccl::logger::WARN_PLUS, &std::cerr);
-
-    dccl::DynamicProtobufManager::enable_compilation();
-    
-    for(std::set<std::string>::const_iterator it = cfg.include.begin(),
-            end = cfg.include.end(); it != end; ++it)
-        dccl::DynamicProtobufManager::add_include_path(*it);
-
-    dccl::Codec dccl;
-    for(std::set<std::string>::const_iterator it = cfg.dlopen.begin(),
-            end = cfg.dlopen.end(); it != end; ++it)
-        dccl.load_library(*it);
-    
-    for(std::set<std::string>::const_iterator it = cfg.proto_file.begin(),
-            end = cfg.proto_file.end(); it != end; ++it)
-    {
-        const google::protobuf::FileDescriptor* file_desc =
-            dccl::DynamicProtobufManager::load_from_proto_file(*it);
-
-        if(!file_desc)
-        {
-            std::cerr << "failed to read in: " << *it << std::endl;
-            exit(EXIT_FAILURE);
-        }
-        
-        // if no messages explicity specified, load them all.
-        if(cfg.message.empty())
-        {
-            for(int i = 0, n = file_desc->message_type_count(); i < n; ++i)
-            {
-                const google::protobuf::Descriptor* desc = file_desc->message_type(i);
-                cfg.message.insert(file_desc->message_type(i)->full_name());
-            }
-        }
-    }
-
-    // Load up all the messages
-    for(std::set<std::string>::const_iterator it = cfg.message.begin(),
-            end = cfg.message.end(); it != end; ++it)   
-    {
-        const google::protobuf::Descriptor* desc = 
-            dccl::DynamicProtobufManager::find_descriptor(*it);
-        load_desc(&dccl, desc, *it);
-    }
-
-    switch(cfg.action)
-    {
-        case ENCODE: encode(dccl, cfg); break;
-        case DECODE: decode(dccl, cfg); break;
-        case ANALYZE: analyze(dccl, cfg); break;
-        case DISP_PROTO: disp_proto(dccl, cfg); break;
-        default:
-            std::cerr << "No action specified (e.g. analyze, decode, encode). Try --help." << std::endl;
-            exit(EXIT_SUCCESS);
-        
-    }
+    std::vector<void *> dl_handles;
+    {
+        Config cfg;
+        parse_options(argc, argv, &cfg);
+
+        if(!cfg.verbose)
+            dccl::dlog.connect(dccl::logger::WARN_PLUS, &std::cerr);
+        else
+            dccl::dlog.connect(dccl::logger::DEBUG1_PLUS, &std::cerr);
+        
+        dccl::DynamicProtobufManager::enable_compilation();
+    
+        for(std::set<std::string>::const_iterator it = cfg.include.begin(),
+                end = cfg.include.end(); it != end; ++it)
+            dccl::DynamicProtobufManager::add_include_path(*it);
+    
+        for(std::set<std::string>::const_iterator it = cfg.dlopen.begin(),
+                end = cfg.dlopen.end(); it != end; ++it)
+        {
+            void* handle = dlopen(it->c_str(), RTLD_LAZY);
+            if(handle)
+            {
+                dl_handles.push_back(handle);
+            }
+            else
+            {
+                std::cerr << "Failed to open shared library: " << *it << std::endl;
+                exit(EXIT_FAILURE);
+            }
+        
+        }
+
+        dccl::Codec dccl(cfg.id_codec);
+        for(std::vector<void *>::iterator it = dl_handles.begin(),
+                n = dl_handles.end(); it != n; ++it)
+            dccl.load_library(*it);
+
+        bool no_messages_specified = cfg.message.empty();
+        for(std::set<std::string>::const_iterator it = cfg.proto_file.begin(),
+                end = cfg.proto_file.end(); it != end; ++it)
+        {
+            const google::protobuf::FileDescriptor* file_desc =
+                dccl::DynamicProtobufManager::load_from_proto_file(*it);
+
+            if(!file_desc)
+            {
+                std::cerr << "failed to read in: " << *it << std::endl;
+                exit(EXIT_FAILURE);
+            }
+        
+            // if no messages explicitly specified, load them all.
+            if(no_messages_specified && cfg.action != ENCODE)
+            {
+                for(int i = 0, n = file_desc->message_type_count(); i < n; ++i)
+                {
+                    cfg.message.insert(file_desc->message_type(i)->full_name());
+                }
+            }
+        }
+
+        // Load up all the messages
+        for(std::set<std::string>::const_iterator it = cfg.message.begin(),
+                end = cfg.message.end(); it != end; ++it)   
+        {
+            const google::protobuf::Descriptor* desc = 
+                dccl::DynamicProtobufManager::find_descriptor(*it);
+            load_desc(&dccl, desc, *it);
+        }
+
+        switch(cfg.action)
+        {
+            case ENCODE: encode(dccl, cfg); break;
+            case DECODE: decode(dccl, cfg); break;
+            case ANALYZE: analyze(dccl, cfg); break;
+            case DISP_PROTO: disp_proto(dccl, cfg); break;
+            default:
+                std::cerr << "No action specified (e.g. analyze, decode, encode). Try --help." << std::endl;
+                exit(EXIT_SUCCESS);
+        
+        }
+    }
+
+    for(std::vector<void *>::iterator it = dl_handles.begin(),
+            n = dl_handles.end(); it != n; ++it)
+        dlclose(*it);
+    
 }
 
 
@@ -137,16 +173,14 @@
     dccl.info_all(&std::cout);
 }
 
-void encode(dccl::Codec& dccl, const Config& cfg)
+void encode(dccl::Codec& dccl, Config& cfg)
 {
-    if(cfg.message.size() != 1)
+    if(cfg.message.size() > 1)
     {
-        std::cerr << "Exactly one DCCL message must be specified with -m or --message" << std::endl;
+        std::cerr << "No more than one DCCL message can be specified with -m or --message for encoding." << std::endl;
         exit(EXIT_FAILURE);
     }
-    const google::protobuf::Descriptor* desc = 
-        dccl::DynamicProtobufManager::find_descriptor(*cfg.message.begin());
-    int dccl_id = dccl.id(desc);
+    std::string command_line_name = *cfg.message.begin();
     
     while(!std::cin.eof())
     {
@@ -156,6 +190,50 @@
         boost::trim(input);
         if(input.empty())
             continue;
+
+        std::string name;
+        if(input[0] == '|')
+        {
+            std::string::size_type close_bracket_pos = input.find('|', 1);
+            if(close_bracket_pos == std::string::npos)
+            {
+                std::cerr << "Incorrectly formatted input: expected '|'" << std::endl;
+                exit(EXIT_FAILURE);
+            }
+
+            name = input.substr(1, close_bracket_pos-1);
+            if(cfg.message.find(name) == cfg.message.end())
+            {
+                const google::protobuf::Descriptor* desc = 
+                    dccl::DynamicProtobufManager::find_descriptor(name);
+                load_desc(&dccl, desc, name);
+                cfg.message.insert(name);
+            }
+            
+            
+            if(input.size() > close_bracket_pos+1)
+                input = input.substr(close_bracket_pos+1);
+            else
+                input.clear();
+        }
+        else
+        {
+            if(cfg.message.size() == 0)
+            {
+                std::cerr << "Message name not given with -m or in the input (i.e. '[Name] field1: value field2: value')." << std::endl;
+                exit(EXIT_FAILURE);
+            }
+                
+            name = command_line_name;
+        }
+        
+        const google::protobuf::Descriptor* desc = dccl::DynamicProtobufManager::find_descriptor(name);
+        if(desc == 0)
+        {
+            std::cerr << "No descriptor with name " << name << " found! Make sure you have loaded all the necessary .proto files and/or shared libraries. Also make sure you specified the fully qualified name including the package, if any (e.g. 'goby.acomms.protobuf.NetworkAck', not just 'NetworkAck')." << std::endl;
+            exit(EXIT_FAILURE);
+        }
+        
         
         boost::shared_ptr<google::protobuf::Message> msg = dccl::DynamicProtobufManager::new_protobuf_message(desc);
         google::protobuf::TextFormat::ParseFromString(input, msg.get());
@@ -167,6 +245,13 @@
             switch(cfg.format)
             {
                 default:
+                case BINARY:                    
+                {    
+                    std::ofstream fout("/dev/stdout", std::ios::binary | std::ios::app);
+                    fout.write(encoded.data(), encoded.size()); 
+                    break;
+                }
+                
                 case TEXTFORMAT:
                 {
                     
@@ -197,49 +282,61 @@
 
 void decode(dccl::Codec& dccl, const Config& cfg)
 {
-    if(cfg.message.size() != 1)
+    std::string input;
+    if(cfg.format == BINARY)
     {
-        std::cerr << "Exactly one DCCL message must be specified with -m or --message" << std::endl;
-        exit(EXIT_FAILURE);
+        std::ifstream fin("/dev/stdin", std::ios::binary);
+        std::ostringstream ostrm;
+        ostrm << fin.rdbuf();
+        input = ostrm.str();
     }
-        
-    while(!std::cin.eof())
+    else
     {
-        std::string input;
-        std::getline (std::cin, input);
-
-        if(boost::trim_copy(input).empty())
-            continue;
-        
-        switch(cfg.format)
+        while(!std::cin.eof())
         {
-            default:
-            case TEXTFORMAT:
+            std::string line;
+            std::getline (std::cin, line);
+            
+            if(boost::trim_copy(line).empty())
+                continue;
+            
+            switch(cfg.format)
             {
-                boost::trim_if(input, boost::is_any_of("\""));
-
-                
-                ByteString s;
-                google::protobuf::TextFormat::ParseFieldValueFromString("\"" + input + "\"", s.GetDescriptor()->FindFieldByNumber(1), &s);
-                input = s.b();
-                break;
+                default:
+                case BINARY:
+                    break;
+                    
+                case TEXTFORMAT:
+                {
+                    boost::trim_if(line, boost::is_any_of("\""));
+                    
+                    
+                    ByteString s;
+                    google::protobuf::TextFormat::ParseFieldValueFromString("\"" + line + "\"", s.GetDescriptor()->FindFieldByNumber(1), &s);
+                    input += s.b();
+                    break;
+                }
+                case HEX:
+                    input += dccl::hex_decode(line);
+                    break;
+                case BASE64:
+                    std::stringstream instream(line);
+                    std::stringstream outstream;
+                    base64::decoder D;
+                    D.decode(instream, outstream);
+                    input += outstream.str();
+                    break;
             }
-            case HEX:
-                input = dccl::hex_decode(input);
-                break;
-            case BASE64:
-                std::string in = input;
-                std::stringstream instream(input);
-                std::stringstream outstream;
-                base64::decoder D;
-		D.decode(instream, outstream);
-                input = outstream.str();
-                break;
         }
+    }
 
-        boost::shared_ptr<google::protobuf::Message> msg = dccl.decode<boost::shared_ptr<google::protobuf::Message> >(input);
+    while(!input.empty())
+    {
+        boost::shared_ptr<google::protobuf::Message> msg = dccl.decode<boost::shared_ptr<google::protobuf::Message> >(&input);
+        if(!cfg.omit_prefix)
+            std::cout << "|" << msg->GetDescriptor()->full_name() << "| ";
         std::cout << msg->ShortDebugString() << std::endl;
-    }    
+    }
 }
 
 void disp_proto(dccl::Codec& dccl, const Config& cfg)
@@ -286,7 +383,10 @@
     options.push_back(dccl::Option('l', "dlopen", required_argument, "Open this shared library containing compiled DCCL messages."));
     options.push_back(dccl::Option('m', "message", required_argument, "Message name to encode, decode or analyze."));
     options.push_back(dccl::Option('f', "proto_file", required_argument, ".proto file to load."));
-    options.push_back(dccl::Option(0, "format", required_argument, "Format for encode output or decode input: 'hex' is ascii-encoded hexadecimal (default), 'textformat' is a Google Protobuf TextFormat byte string, 'base64' is ascii-encoded base 64."));
+    options.push_back(dccl::Option(0, "format", required_argument, "Format for encode output or decode input: 'bin' (default) is raw binary, 'hex' is ascii-encoded hexadecimal, 'textformat' is a Google Protobuf TextFormat byte string, 'base64' is ascii-encoded base 64."));
+    options.push_back(dccl::Option('v', "verbose", no_argument, "Display extra debugging information."));
+    options.push_back(dccl::Option('o', "omit_prefix", no_argument, "Omit the DCCL type name prefix from the output of decode."));
+    options.push_back(dccl::Option('i', "id_codec", required_argument, "(Advanced) name for a nonstandard DCCL ID codec to use"));
     
     std::vector<option> long_options; 
     std::string opt_string;
@@ -314,6 +414,8 @@
                         cfg->format = HEX;
                     else if(!strcmp(optarg, "base64"))
                         cfg->format = BASE64;
+                    else if(!strcmp(optarg, "bin"))
+                        cfg->format = BINARY;
                     else
                     {
                         std::cerr << "Invalid format '" << optarg << "'" << std::endl;
@@ -336,6 +438,9 @@
             case 'l': cfg->dlopen.insert(optarg); break;
             case 'm': cfg->message.insert(optarg); break;
             case 'f': cfg->proto_file.insert(optarg); break;                
+            case 'i': cfg->id_codec = optarg; break;                
+            case 'v': cfg->verbose = true; break;                
+            case 'o': cfg->omit_prefix = true; break;                
                 
             case 'h':
                 std::cout << "Usage of the Dynamic Compact Control Language (DCCL) tool ('dccl'): " << std::endl;

=== modified file 'src/arithmetic/field_codec_arithmetic.cpp'
--- src/arithmetic/field_codec_arithmetic.cpp	2013-06-18 12:55:43 +0000
+++ src/arithmetic/field_codec_arithmetic.cpp	2014-08-27 16:27:22 +0000
@@ -38,9 +38,9 @@
 
 // shared library load
 
-extern "C"
+struct CodecLoader
 {
-    void dccl3_load(dccl::Codec* dccl)
+    CodecLoader()
     {
         using namespace dccl;
         
@@ -53,6 +53,29 @@
         FieldCodecManager::add<ArithmeticFieldCodec<bool> >("_arithmetic");
         FieldCodecManager::add<ArithmeticFieldCodec<const google::protobuf::EnumValueDescriptor*> >("_arithmetic");
     }
+    ~CodecLoader()
+    {
+        using namespace dccl;
+        
+        FieldCodecManager::remove<ArithmeticFieldCodec<int32> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<int64> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<uint32> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<uint64> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<double> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<float> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<bool> >("_arithmetic");
+        FieldCodecManager::remove<ArithmeticFieldCodec<const google::protobuf::EnumValueDescriptor*> >("_arithmetic");
+    }
+};
+    
+
+static CodecLoader loader;
+
+extern "C"
+{
+    void dccl3_load(dccl::Codec* dccl)
+    {
+    }
 }
 
 dccl::Model::symbol_type dccl::Model::value_to_symbol(value_type value) const

=== modified file 'src/binary.h'
--- src/binary.h	2014-04-22 20:10:37 +0000
+++ src/binary.h	2014-08-27 16:27:22 +0000
@@ -29,6 +29,8 @@
 #include <sstream>
 
 #include "dccl/common.h"
+#include "dccl/b64/encode.h"
+#include "dccl/b64/decode.h"
 
 namespace dccl
 {
@@ -124,6 +126,27 @@
         hex_encode(in, &out);
         return out;
     }
+
+
+    inline std::string b64_encode(const std::string& in)
+    {
+        std::stringstream instream(in);
+        std::stringstream outstream;
+        base64::encoder D;
+        D.encode(instream, outstream);
+        return outstream.str();
+    }
+
+    inline std::string b64_decode(const std::string& in)
+    {
+        std::stringstream instream(in);
+        std::stringstream outstream;
+        base64::decoder D;
+        D.decode(instream, outstream);
+        return outstream.str();
+    }
+
+    
         
     /// \return ceil(log2(v))
     inline unsigned ceil_log2(dccl::uint64 v)

=== modified file 'src/ccl/CMakeLists.txt'
--- src/ccl/CMakeLists.txt	2014-01-06 17:25:02 +0000
+++ src/ccl/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -17,7 +17,6 @@
 set_target_properties(dccl_ccl_compat 
   PROPERTIES VERSION "${DCCL_VERSION}" SOVERSION "${DCCL_SOVERSION}")
 
-
 install(TARGETS dccl_ccl_compat EXPORT dccl-config
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib) 

=== modified file 'src/ccl/ccl_compatibility.cpp'
--- src/ccl/ccl_compatibility.cpp	2013-06-18 12:55:43 +0000
+++ src/ccl/ccl_compatibility.cpp	2014-08-27 16:27:22 +0000
@@ -31,27 +31,54 @@
 
 // shared library load
 
+struct CodecLoader
+{
+    CodecLoader()
+        {
+            using namespace dccl;
+            FieldCodecManager::add<LegacyCCLIdentifierCodec>("dccl.ccl.id");
+
+            FieldCodecManager::add<LegacyCCLLatLonCompressedCodec>("_ccl_latloncompressed");
+            FieldCodecManager::add<LegacyCCLFixAgeCodec>("_ccl_fix_age");
+            FieldCodecManager::add<LegacyCCLTimeDateCodec>("_ccl_time_date");
+            FieldCodecManager::add<LegacyCCLHeadingCodec>("_ccl_heading");
+            FieldCodecManager::add<LegacyCCLDepthCodec>("_ccl_depth");
+            FieldCodecManager::add<LegacyCCLVelocityCodec>("_ccl_velocity");
+            FieldCodecManager::add<LegacyCCLWattsCodec>("_ccl_watts");
+            FieldCodecManager::add<LegacyCCLGFIPitchOilCodec>("_ccl_gfi_pitch_oil");
+            FieldCodecManager::add<LegacyCCLSpeedCodec>("_ccl_speed");
+            FieldCodecManager::add<LegacyCCLHiResAltitudeCodec>("_ccl_hires_altitude");
+            FieldCodecManager::add<LegacyCCLTemperatureCodec>("_ccl_temperature");
+            FieldCodecManager::add<LegacyCCLSalinityCodec>("_ccl_salinity");
+            FieldCodecManager::add<LegacyCCLSoundSpeedCodec>("_ccl_sound_speed");
+        }
+    ~CodecLoader()
+        {
+            using namespace dccl;
+            FieldCodecManager::remove<LegacyCCLIdentifierCodec>("dccl.ccl.id");
+
+            FieldCodecManager::remove<LegacyCCLLatLonCompressedCodec>("_ccl_latloncompressed");
+            FieldCodecManager::remove<LegacyCCLFixAgeCodec>("_ccl_fix_age");
+            FieldCodecManager::remove<LegacyCCLTimeDateCodec>("_ccl_time_date");
+            FieldCodecManager::remove<LegacyCCLHeadingCodec>("_ccl_heading");
+            FieldCodecManager::remove<LegacyCCLDepthCodec>("_ccl_depth");
+            FieldCodecManager::remove<LegacyCCLVelocityCodec>("_ccl_velocity");
+            FieldCodecManager::remove<LegacyCCLWattsCodec>("_ccl_watts");
+            FieldCodecManager::remove<LegacyCCLGFIPitchOilCodec>("_ccl_gfi_pitch_oil");
+            FieldCodecManager::remove<LegacyCCLSpeedCodec>("_ccl_speed");
+            FieldCodecManager::remove<LegacyCCLHiResAltitudeCodec>("_ccl_hires_altitude");
+            FieldCodecManager::remove<LegacyCCLTemperatureCodec>("_ccl_temperature");
+            FieldCodecManager::remove<LegacyCCLSalinityCodec>("_ccl_salinity");
+            FieldCodecManager::remove<LegacyCCLSoundSpeedCodec>("_ccl_sound_speed");
+        }
+};
+    
+static CodecLoader loader;
 
 extern "C"
 {
     void dccl3_load(dccl::Codec* dccl)
-    {
-        using namespace dccl;
-        
-        FieldCodecManager::add<LegacyCCLLatLonCompressedCodec>("_ccl_latloncompressed");
-        FieldCodecManager::add<LegacyCCLFixAgeCodec>("_ccl_fix_age");
-        FieldCodecManager::add<LegacyCCLTimeDateCodec>("_ccl_time_date");
-        FieldCodecManager::add<LegacyCCLHeadingCodec>("_ccl_heading");
-        FieldCodecManager::add<LegacyCCLDepthCodec>("_ccl_depth");
-        FieldCodecManager::add<LegacyCCLVelocityCodec>("_ccl_velocity");
-        FieldCodecManager::add<LegacyCCLWattsCodec>("_ccl_watts");
-        FieldCodecManager::add<LegacyCCLGFIPitchOilCodec>("_ccl_gfi_pitch_oil");
-        FieldCodecManager::add<LegacyCCLSpeedCodec>("_ccl_speed");
-        FieldCodecManager::add<LegacyCCLHiResAltitudeCodec>("_ccl_hires_altitude");
-        FieldCodecManager::add<LegacyCCLTemperatureCodec>("_ccl_temperature");
-        FieldCodecManager::add<LegacyCCLSalinityCodec>("_ccl_salinity");
-        FieldCodecManager::add<LegacyCCLSoundSpeedCodec>("_ccl_sound_speed");
-        
+    {        
         dccl->load<dccl::protobuf::CCLMDATEmpty>();
         dccl->load<dccl::protobuf::CCLMDATRedirect>();
         dccl->load<dccl::protobuf::CCLMDATBathy>();

=== modified file 'src/ccl/ccl_compatibility.h'
--- src/ccl/ccl_compatibility.h	2013-09-12 16:23:45 +0000
+++ src/ccl/ccl_compatibility.h	2014-08-27 16:27:22 +0000
@@ -24,7 +24,8 @@
 #ifndef DCCLCCLCOMPATIBILITY20120426H
 #define DCCLCCLCOMPATIBILITY20120426H
 
-#include "dccl/field_codec_default.h"
+#include "dccl/codecs2/field_codec_default.h"
+#include "dccl/field_codec_id.h"
 #include "dccl/ccl/protobuf/ccl.pb.h"
 #include "dccl/ccl/protobuf/ccl_extensions.pb.h"
 
@@ -33,8 +34,6 @@
     void dccl3_load(dccl::Codec* dccl);
 }
 
-
-
 namespace dccl
 {
     const unsigned char DCCL_CCL_HEADER = 32;
@@ -117,7 +116,7 @@
         enum { LATLON_COMPRESSED_BYTE_SIZE = 3 };            
     };
 
-    class LegacyCCLFixAgeCodec : public dccl::DefaultNumericFieldCodec<dccl::uint32>
+    class LegacyCCLFixAgeCodec : public dccl::v2::DefaultNumericFieldCodec<dccl::uint32>
     {
       private:
         dccl::Bitset encode()

=== modified file 'src/codec.cpp'
--- src/codec.cpp	2014-04-22 20:10:37 +0000
+++ src/codec.cpp	2014-08-27 16:27:22 +0000
@@ -38,7 +38,9 @@
 #endif // HAS_CRYPTOPP
 
 #include "dccl/codec.h"
-#include "field_codec_default.h"
+#include "dccl/codecs2/field_codec_default.h"
+#include "dccl/codecs3/field_codec_default.h"
+#include "dccl/field_codec_id.h"
 
 #include "dccl/protobuf/option_extensions.pb.h"
 
@@ -63,7 +65,7 @@
 dccl::Codec::Codec(const std::string& dccl_id_codec)
     : id_codec_(dccl_id_codec)
 {
-    FieldCodecManager::add<DefaultIdentifierCodec>("_default_id_codec");
+    FieldCodecManager::add<DefaultIdentifierCodec>(default_id_codec_name());
     // make sure the id codec exists
     id_codec();
     set_default_codecs();
@@ -77,31 +79,59 @@
     if(!defaults_loaded)
     {
         using google::protobuf::FieldDescriptor;
-
-        FieldCodecManager::add<DefaultNumericFieldCodec<double> >(default_codec_name());
-        FieldCodecManager::add<DefaultNumericFieldCodec<float> >(default_codec_name());
-        FieldCodecManager::add<DefaultBoolCodec>(default_codec_name());
-        FieldCodecManager::add<DefaultNumericFieldCodec<int32> >(default_codec_name());
-        FieldCodecManager::add<DefaultNumericFieldCodec<int64> >(default_codec_name());
-        FieldCodecManager::add<DefaultNumericFieldCodec<uint32> >(default_codec_name());
-        FieldCodecManager::add<DefaultNumericFieldCodec<uint64> >(default_codec_name());
-        FieldCodecManager::add<DefaultStringCodec, FieldDescriptor::TYPE_STRING>(default_codec_name());
-        FieldCodecManager::add<DefaultBytesCodec, FieldDescriptor::TYPE_BYTES>(default_codec_name());
-        FieldCodecManager::add<DefaultEnumCodec>(default_codec_name());
-        FieldCodecManager::add<DefaultMessageCodec, FieldDescriptor::TYPE_MESSAGE>(default_codec_name());
-        
-        FieldCodecManager::add<TimeCodec<uint64> >("_time");
-        FieldCodecManager::add<TimeCodec<int64> >("_time");
-        FieldCodecManager::add<TimeCodec<double> >("_time");
-        
-        FieldCodecManager::add<StaticCodec<std::string> >("_static");
-        FieldCodecManager::add<StaticCodec<double> >("_static");
-        FieldCodecManager::add<StaticCodec<float> >("_static");
-        FieldCodecManager::add<StaticCodec<int32> >("_static");
-        FieldCodecManager::add<StaticCodec<int64> >("_static");
-        FieldCodecManager::add<StaticCodec<uint32> >("_static");
-        FieldCodecManager::add<StaticCodec<uint64> >("_static");
-
+        
+        // version 2
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<double> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<float> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultBoolCodec>(default_codec_name());
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<int32> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<int64> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<uint32> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultNumericFieldCodec<uint64> >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultStringCodec, FieldDescriptor::TYPE_STRING>(default_codec_name());
+        FieldCodecManager::add<v2::DefaultBytesCodec, FieldDescriptor::TYPE_BYTES>(default_codec_name());
+        FieldCodecManager::add<v2::DefaultEnumCodec >(default_codec_name());
+        FieldCodecManager::add<v2::DefaultMessageCodec, FieldDescriptor::TYPE_MESSAGE>(default_codec_name());
+
+        FieldCodecManager::add<v2::TimeCodec<uint64> >("dccl.time2");
+        FieldCodecManager::add<v2::TimeCodec<int64> >("dccl.time2");
+        FieldCodecManager::add<v2::TimeCodec<double> >("dccl.time2");
+
+        FieldCodecManager::add<v2::StaticCodec<std::string> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<double> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<float> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<int32> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<int64> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<uint32> >("dccl.static2");
+        FieldCodecManager::add<v2::StaticCodec<uint64> >("dccl.static2");
+
+        // version 3
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<double> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<float> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultBoolCodec>(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<int32> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<int64> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<uint32> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultNumericFieldCodec<uint64> >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultStringCodec, FieldDescriptor::TYPE_STRING>(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultBytesCodec, FieldDescriptor::TYPE_BYTES>(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultEnumCodec >(default_codec_name(3));
+        FieldCodecManager::add<v3::DefaultMessageCodec, FieldDescriptor::TYPE_MESSAGE>(default_codec_name(3));
+        
+        // for backwards compatibility
+        FieldCodecManager::add<v2::TimeCodec<uint64> >("_time");
+        FieldCodecManager::add<v2::TimeCodec<int64> >("_time");
+        FieldCodecManager::add<v2::TimeCodec<double> >("_time");
+
+        FieldCodecManager::add<v2::StaticCodec<std::string> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<double> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<float> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<int32> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<int64> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<uint32> >("_static");
+        FieldCodecManager::add<v2::StaticCodec<uint64> >("_static");
+        
+        
         defaults_loaded = true;
     }
 }
@@ -326,6 +356,9 @@
             throw(Exception("Missing message option `(dccl.msg).id`. Specify a unique id (e.g. 3) in the body of your .proto message using \"option (dccl.msg).id = 3\""));
         if(!desc->options().GetExtension(dccl::msg).has_max_bytes())
             throw(Exception("Missing message option `(dccl.msg).max_bytes`. Specify a maximum (encoded) message size in bytes (e.g. 32) in the body of your .proto message using \"option (dccl.msg).max_bytes = 32\""));
+
+        if(!desc->options().GetExtension(dccl::msg).has_codec_version())
+            dlog.is(WARN) && dlog << "** NOTE: No (dccl.msg).codec_version set for DCCL Message '" << desc->full_name() <<  "'. Unless you need backwards compatibility with Goby 2.0 (DCCL2), we highly recommend setting 'option (dccl.msg).codec_version = 3' in the message definition for " << desc->full_name() << " to use the default DCCL3 codecs. If you need compatibility with Goby 2.0, ignore this warning, or set 'option (dccl.msg).codec_version = 2' to remove this warning. **" << std::endl;
         
         boost::shared_ptr<FieldCodecBase> codec = FieldCodecManager::find(desc);
 
@@ -419,7 +452,8 @@
             const unsigned allowed_byte_size = desc->options().GetExtension(dccl::msg).max_bytes();
             const unsigned allowed_bit_size = allowed_byte_size * BITS_IN_BYTE;
 
-            std::string guard = std::string((full_width-desc->full_name().size())/2, '=');
+            std::string message_name = boost::lexical_cast<std::string>(dccl_id) + ": " + desc->full_name();
+            std::string guard = std::string((full_width-message_name.size())/2, '=');
 
             std::string bits_dccl_head_str = "dccl.id head";
             std::string bits_user_head_str = "user head";
@@ -430,7 +464,7 @@
             const int spaces = 8;
             std::string indent = std::string(spaces,' ');
             
-            *os << guard << " " << desc->full_name() << " " << guard << "\n"
+            *os << guard << " " << message_name << " " << guard << "\n"
                 << "Actual maximum size of message: " << byte_size << " bytes / "
                 << byte_size*BITS_IN_BYTE  << " bits\n"
                 << indent << bits_dccl_head_str << std::setfill('.') << std::setw(bits_width-bits_dccl_head_str.size()) << id_bit_size << "\n"
@@ -443,7 +477,7 @@
             std::string header_str = "Header";
             std::string header_guard = std::string((full_width-header_str.size())/2, '-');
             *os << header_guard << " " << header_str << " " << header_guard << std::endl;
-            *os << bits_dccl_head_str << std::setfill('.') << std::setw(bits_width-bits_dccl_head_str.size()+spaces) << id_bit_size << "\n";
+            *os << bits_dccl_head_str << std::setfill('.') << std::setw(bits_width-bits_dccl_head_str.size()+spaces) << id_bit_size << " {" << id_codec()->name() <<  "}\n";
             codec->base_info(os, desc, MessageStack::HEAD);
 //            *os << std::string(header_str.size() + 2 + 2*header_guard.size(), '-') << std::endl;
             
@@ -459,6 +493,9 @@
         {
             dlog.is(DEBUG1) && dlog << "Message " << desc->full_name() << " cannot provide information due to invalid configuration. Reason: " << e.what() << std::endl;
         }
+
+        os->flush();
+        
     }
     
 }
@@ -564,4 +601,5 @@
         
 //        *os << std::string(codec_str.size() + 2 + 2*codec_guard.size(), '|') << std::endl;
     }
+
 }

=== modified file 'src/codec.h'
--- src/codec.h	2014-04-22 20:10:37 +0000
+++ src/codec.h	2014-08-27 16:27:22 +0000
@@ -42,7 +42,9 @@
 #include "exception.h"
 #include "field_codec.h"
 #include "field_codec_fixed.h"
-#include "field_codec_default.h"
+
+#include "codecs2/field_codec_default_message.h"
+#include "codecs3/field_codec_default_message.h"
 #include "type_helper.h"
 #include "field_codec_manager.h"
  
@@ -84,7 +86,7 @@
     class Codec
     {
       public:       
-        Codec(const std::string& dccl_id_codec = "_default_id_codec");
+        Codec(const std::string& dccl_id_codec = default_id_codec_name());
         virtual ~Codec()
         {
             for(std::vector<void *>::iterator it = dl_handles_.begin(),
@@ -181,6 +183,9 @@
             return desc->options().GetExtension(dccl::msg).id();
         }            
 
+        /// \brief Provides a map of all loaded DCCL IDs to the equivalent Protobuf descriptor
+        const std::map<int32, const google::protobuf::Descriptor*>& loaded() const { return id2desc_; }
+        
         //@}
             
         /// \brief Provides the encoded size (in bytes) of msg. This is useful if you need to know the size of a message before encoding it (encoding it is generally much more expensive than calling this method)
@@ -237,8 +242,26 @@
         /// \return pointer to decoded message (a google::protobuf::Message). You are responsible for deleting the memory used by this pointer, so we recommend using a smart pointer here (e.g. boost::shared_ptr or the C++11 equivalent). This message can be examined using the Google Reflection/Descriptor API.
         template<typename GoogleProtobufMessagePointer>
             GoogleProtobufMessagePointer decode(std::string* bytes);
-
-        friend class DefaultMessageCodec;
+      
+        static std::string default_id_codec_name()
+        { return "dccl.default.id"; }        
+
+        
+        static std::string default_codec_name(int version = 2)
+        {
+            switch(version)
+            {
+                case 2:
+                    return dccl::DCCLFieldOptions::descriptor()->FindFieldByName("codec")->default_value_string();
+                default:
+                    return "dccl.default" + boost::lexical_cast<std::string>(version);
+            }
+            
+        }
+
+        
+        friend class v2::DefaultMessageCodec;
+        //friend class v3::DefaultMessageCodec;
       private:
         Codec(const Codec&);
         Codec& operator= (const Codec&);
@@ -254,11 +277,6 @@
                                            id_codec_);
         }
         
-        static const std::string& default_codec_name()
-        {
-            return dccl::DCCLFieldOptions::descriptor()->FindFieldByName("codec")->default_value_string();
-        }        
-        
       private:
         // SHA256 hash of the crypto passphrase
         std::string crypto_key_;
@@ -287,7 +305,7 @@
     unsigned this_id = id(bytes);   
 
     if(!id2desc_.count(this_id))
-        throw(Exception("Message id " + boost::lexical_cast<std::string>(this_id) + " has not been validated. Call validate() before decoding this type."));
+        throw(Exception("Message id " + boost::lexical_cast<std::string>(this_id) + " has not been loaded. Call load() before decoding this type."));
                     
     // ownership of this object goes to the caller of decode()
     GoogleProtobufMessagePointer msg =

=== added directory 'src/codecs2'
=== renamed file 'src/field_codec_default.cpp' => 'src/codecs2/field_codec_default.cpp'
--- src/field_codec_default.cpp	2014-04-22 20:10:37 +0000
+++ src/codecs2/field_codec_default.cpp	2014-08-27 16:27:22 +0000
@@ -25,108 +25,28 @@
 #include <sstream>
 #include <algorithm>
 
-#include "field_codec_default.h"
-#include "type_helper.h"
+#include "dccl/codecs2/field_codec_default.h"
+#include "dccl/type_helper.h"
 #include "dccl/codec.h"
 
 using namespace dccl::logger;
 
 
 //
-// DefaultIdentifierCodec
-//
-
-dccl::Bitset dccl::DefaultIdentifierCodec::encode()
-{
-    return encode(0);
-}
-
-dccl::Bitset dccl::DefaultIdentifierCodec::encode(const uint32& id)
-{
-    if(id <= ONE_BYTE_MAX_ID)
-    {
-        return(dccl::Bitset(this_size(id), id) << 1);
-    }
-    else
-    {
-        dccl::Bitset return_bits(this_size(id), id);
-        return_bits <<= 1;
-        // set LSB to indicate long header form
-        return_bits.set(0, true);
-
-        
-        return return_bits;
-    }
-}
-
-dccl::uint32 dccl::DefaultIdentifierCodec::decode(Bitset* bits)
-{
-    if(bits->test(0))
-    {
-        // long header
-        // grabs more bits to add to the MSB of `bits`
-        bits->get_more_bits((LONG_FORM_ID_BYTES - SHORT_FORM_ID_BYTES)*BITS_IN_BYTE);
-        // discard identifier
-        *(bits) >>= 1;
-        return bits->to_ulong();
-    }
-    else
-    {
-        // short header
-        *(bits) >>= 1;
-        return bits->to_ulong();
-    }
-}
-
-unsigned dccl::DefaultIdentifierCodec::size()
-{
-    return this_size(0);
-}
-
-unsigned dccl::DefaultIdentifierCodec::size(const uint32& id)
-{
-    return this_size(id);
-}
-
-unsigned dccl::DefaultIdentifierCodec::this_size(const uint32& id)
-{
-    if(id > TWO_BYTE_MAX_ID)
-        throw(Exception("dccl.id provided (" + boost::lexical_cast<std::string>(id) + ") exceeds maximum: " + boost::lexical_cast<std::string>(int(TWO_BYTE_MAX_ID))));
-    
-    return (id <= ONE_BYTE_MAX_ID) ?
-        SHORT_FORM_ID_BYTES*BITS_IN_BYTE :
-        LONG_FORM_ID_BYTES*BITS_IN_BYTE;
-}
-
-
-unsigned dccl::DefaultIdentifierCodec::max_size()
-{
-    return LONG_FORM_ID_BYTES * BITS_IN_BYTE;
-}
-
-unsigned dccl::DefaultIdentifierCodec::min_size()
-{
-    return SHORT_FORM_ID_BYTES * BITS_IN_BYTE;
-}
-
-
-        
-
-//
 // DefaultBoolCodec
 //
 
-dccl::Bitset dccl::DefaultBoolCodec::encode()
+dccl::Bitset dccl::v2::DefaultBoolCodec::encode()
 {
     return Bitset(size());
 }
 
-dccl::Bitset dccl::DefaultBoolCodec::encode(const bool& wire_value)
+dccl::Bitset dccl::v2::DefaultBoolCodec::encode(const bool& wire_value)
 {
     return Bitset(size(), this_field()->is_required() ? wire_value : wire_value + 1);
 }
 
-bool dccl::DefaultBoolCodec::decode(Bitset* bits)
+bool dccl::v2::DefaultBoolCodec::decode(Bitset* bits)
 {
     unsigned long t = bits->to_ulong();
     if(this_field()->is_required())
@@ -145,7 +65,7 @@
 }
 
 
-unsigned dccl::DefaultBoolCodec::size()
+unsigned dccl::v2::DefaultBoolCodec::size()
 {    
     // true and false
     const unsigned BOOL_VALUES = 2;
@@ -155,19 +75,19 @@
     return dccl::ceil_log2(BOOL_VALUES + NULL_VALUE);
 }
 
-void dccl::DefaultBoolCodec::validate()
+void dccl::v2::DefaultBoolCodec::validate()
 { }
 
 //
 // DefaultStringCodec
 //
 
-dccl::Bitset dccl::DefaultStringCodec::encode()
+dccl::Bitset dccl::v2::DefaultStringCodec::encode()
 {
     return Bitset(min_size());
 }
 
-dccl::Bitset dccl::DefaultStringCodec::encode(const std::string& wire_value)
+dccl::Bitset dccl::v2::DefaultStringCodec::encode(const std::string& wire_value)
 {
     std::string s = wire_value;
     if(s.size() > dccl_field_options().max_length())
@@ -197,7 +117,7 @@
     return length_bits;
 }
 
-std::string dccl::DefaultStringCodec::decode(Bitset* bits)
+std::string dccl::v2::DefaultStringCodec::decode(Bitset* bits)
 {
     unsigned value_length = bits->to_ulong();
     
@@ -228,30 +148,30 @@
     
 }
 
-unsigned dccl::DefaultStringCodec::size()
+unsigned dccl::v2::DefaultStringCodec::size()
 {
     return min_size();
 }
 
-unsigned dccl::DefaultStringCodec::size(const std::string& wire_value)
+unsigned dccl::v2::DefaultStringCodec::size(const std::string& wire_value)
 {
     return std::min(min_size() + static_cast<unsigned>(wire_value.length()*BITS_IN_BYTE), max_size());
 }
 
 
-unsigned dccl::DefaultStringCodec::max_size()
+unsigned dccl::v2::DefaultStringCodec::max_size()
 {
     // string length + actual string
     return min_size() + dccl_field_options().max_length() * BITS_IN_BYTE;
 }
 
-unsigned dccl::DefaultStringCodec::min_size()
+unsigned dccl::v2::DefaultStringCodec::min_size()
 {
     return dccl::ceil_log2(MAX_STRING_LENGTH+1);
 }
 
 
-void dccl::DefaultStringCodec::validate()
+void dccl::v2::DefaultStringCodec::validate()
 {
     require(dccl_field_options().has_max_length(), "missing (dccl.field).max_length");
     require(dccl_field_options().max_length() <= MAX_STRING_LENGTH,
@@ -261,13 +181,13 @@
 //
 // DefaultBytesCodec
 //
-dccl::Bitset dccl::DefaultBytesCodec::encode()
+dccl::Bitset dccl::v2::DefaultBytesCodec::encode()
 {
     return Bitset(min_size(), 0);
 }
 
 
-dccl::Bitset dccl::DefaultBytesCodec::encode(const std::string& wire_value)
+dccl::Bitset dccl::v2::DefaultBytesCodec::encode(const std::string& wire_value)
 {
     Bitset bits;
     bits.from_byte_string(wire_value);
@@ -282,19 +202,19 @@
     return bits;
 }
 
-unsigned dccl::DefaultBytesCodec::size()
+unsigned dccl::v2::DefaultBytesCodec::size()
 {
     return min_size();    
 }
 
 
-unsigned dccl::DefaultBytesCodec::size(const std::string& wire_value)
+unsigned dccl::v2::DefaultBytesCodec::size(const std::string& wire_value)
 {
     return max_size();
 }
 
 
-std::string dccl::DefaultBytesCodec::decode(Bitset* bits)
+std::string dccl::v2::DefaultBytesCodec::decode(Bitset* bits)
 {
     if(!this_field()->is_required())
     {
@@ -320,13 +240,13 @@
     }
 }
 
-unsigned dccl::DefaultBytesCodec::max_size()
+unsigned dccl::v2::DefaultBytesCodec::max_size()
 {
     return dccl_field_options().max_length() * BITS_IN_BYTE +
         (this_field()->is_required() ? 0 : 1); // presence bit?
 }
 
-unsigned dccl::DefaultBytesCodec::min_size()
+unsigned dccl::v2::DefaultBytesCodec::min_size()
 {
     if(this_field()->is_required())
         return max_size();
@@ -334,7 +254,7 @@
         return 1; // presence bit
 }
 
-void dccl::DefaultBytesCodec::validate()
+void dccl::v2::DefaultBytesCodec::validate()
 {
     require(dccl_field_options().has_max_length(), "missing (dccl.field).max_length");
 }
@@ -342,12 +262,12 @@
 //
 // DefaultEnumCodec
 //
-dccl::int32 dccl::DefaultEnumCodec::pre_encode(const google::protobuf::EnumValueDescriptor* const& field_value)
+dccl::int32 dccl::v2::DefaultEnumCodec::pre_encode(const google::protobuf::EnumValueDescriptor* const& field_value)
 {
     return field_value->index();
 }
 
-const google::protobuf::EnumValueDescriptor* dccl::DefaultEnumCodec::post_decode(const dccl::int32& wire_value)
+const google::protobuf::EnumValueDescriptor* dccl::v2::DefaultEnumCodec::post_decode(const dccl::int32& wire_value)
 {
     const google::protobuf::EnumDescriptor* e = this_field()->enum_type();
 

=== renamed file 'src/field_codec_default.h' => 'src/codecs2/field_codec_default.h'
--- src/field_codec_default.h	2014-04-22 20:10:37 +0000
+++ src/codecs2/field_codec_default.h	2014-08-27 16:27:22 +0000
@@ -2,6 +2,7 @@
 //                     GobySoft, LLC (2013-)
 //                     Massachusetts Institute of Technology (2007-2014)
 //                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
 //
 // This file is part of the Dynamic Compact Control Language Library
 // ("DCCL").
@@ -39,328 +40,307 @@
 
 #include "dccl/protobuf/option_extensions.pb.h"
 
-#include "field_codec_default_message.h"
-#include "field_codec_fixed.h"
-#include "field_codec.h"
-#include "binary.h"
+#include "dccl/codecs2/field_codec_default_message.h"
+#include "dccl/field_codec_fixed.h"
+#include "dccl/field_codec.h"
+#include "dccl/binary.h"
 
 namespace dccl
 {
-    /// \brief Provides the default 1 byte or 2 byte DCCL ID codec
-    class DefaultIdentifierCodec : public TypedFieldCodec<uint32>
-    {
-      protected:
-        virtual Bitset encode();
-        virtual Bitset encode(const uint32& wire_value);
-        virtual uint32 decode(Bitset* bits);
-        virtual unsigned size();
-        virtual unsigned size(const uint32& wire_value);
-        virtual unsigned max_size();
-        virtual unsigned min_size();
-        virtual void validate() { }
-
-      private:
-        unsigned this_size(const uint32& wire_value);
-        // maximum id we can fit in short or long header (MSB reserved to indicate
-        // short or long header)
-        enum { ONE_BYTE_MAX_ID = (1 << 7) - 1,
-               TWO_BYTE_MAX_ID = (1 << 15) - 1};
-            
-        enum { SHORT_FORM_ID_BYTES = 1,
-               LONG_FORM_ID_BYTES = 2 };
-    };
-
-        
-
-    /// \brief Provides a basic bounded arbitrary length numeric (double, float, uint32, uint64, int32, int64) encoder.
-    ///
-    /// Takes ceil(log2((max-min)*10^precision)+1) bits for required fields, ceil(log2((max-min)*10^precision)+2) for optional fields.
-    template<typename WireType, typename FieldType = WireType>
-        class DefaultNumericFieldCodec : public TypedFixedFieldCodec<WireType, FieldType>
-    {
-      protected:
-
-      virtual double max()
-      { return FieldCodecBase::dccl_field_options().max(); }
-
-      virtual double min()
-      { return FieldCodecBase::dccl_field_options().min(); }
-
-      virtual double precision()
-      { return FieldCodecBase::dccl_field_options().precision(); }
-      
-      virtual void validate()
-      {
-          FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_min(),
-                                      "missing (dccl.field).min");
-          FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_max(),
-                                      "missing (dccl.field).max");
-
-          validate_numeric_bounds();
-      }
-
-      void validate_numeric_bounds()
-      {
-
-          // ensure given max and min fit within WireType ranges
-          FieldCodecBase::require(min() >= boost::numeric::bounds<WireType>::lowest(),
-                                      "(dccl.field).min must be >= minimum of this field type.");
-          FieldCodecBase::require(max() <= boost::numeric::bounds<WireType>::highest(),
-                                      "(dccl.field).max must be <= maximum of this field type.");
-
-          
-          // ensure value fits into double
-          FieldCodecBase::require((precision() + std::ceil(std::log10(max() - min()))) <= std::numeric_limits<double>::digits10,
-                                  "[(dccl.field).max-(dccl.field).min]*10^(dccl.field).precision must fit in a double-precision floating point value. Please increase min, decrease max, or decrease precision.");
-          
-      }
-      
-      
-      Bitset encode()
-      {
-          return Bitset(size());
-      }
-          
-          
-      virtual Bitset encode(const WireType& value)
-      {
-          WireType wire_value = value;
-                
-          if(wire_value < min() || wire_value > max())
-              return Bitset(size());              
-              
-          wire_value -= (WireType)min();
-
-          wire_value = dccl::round(wire_value, precision());
-          if (precision() < 0) {
-              wire_value /= (WireType)std::pow(10.0, -precision());
-          } else if (precision() > 0) {
-              wire_value *= (WireType)std::pow(10.0, precision());
-          }
-
-          // "presence" value (0)
-          if(!FieldCodecBase::this_field()->is_required())
-              wire_value += 1;
-	  
-
-          Bitset encoded;
-          encoded.from(boost::numeric_cast<dccl::uint64>(dccl::round(wire_value, 0)), size());
-          return encoded;
-      }
-          
-      virtual WireType decode(Bitset* bits)
-      {
-          // The line below SHOULD BE:
-          // dccl::uint64 t = bits->to<dccl::uint64>();
-          // But GCC3.3 requires an explicit template modifier on the method.
-          // See, e.g., http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10959
-          dccl::uint64 uint_value = (bits->template to<dccl::uint64>)();
-
-          if(!FieldCodecBase::this_field()->is_required())
-          {
-              if(!uint_value) throw NullValueException();
-              --uint_value;
-          }
-	  
-	  WireType wire_value = (WireType)uint_value;
-
-          if (precision() < 0) {
-	    wire_value *= (WireType)std::pow(10.0, -precision());
-          } else if (precision() > 0) {
-	    wire_value /= (WireType)std::pow(10.0, precision());
-          }
-
-	  // round values again to properly handle cases where double precision
-	  // leads to slightly off values (e.g. 2.099999999 instead of 2.1)
-          wire_value = dccl::round(wire_value + (WireType)min(),
-					    precision());          
-
-          return wire_value;
-      }
-
-      unsigned size()
-      {
-          // if not required field, leave one value for unspecified (always encoded as 0)
-          const unsigned NULL_VALUE = FieldCodecBase::this_field()->is_required() ? 0 : 1;
-              
-          return dccl::ceil_log2((max()-min())*std::pow(10.0, precision())+1 + NULL_VALUE);
-      }
-            
-    };
-
-    /// \brief Provides a bool encoder. Uses 1 bit if field is `required`, 2 bits if `optional`
-    ///
-    /// [presence bit (0 bits if required, 1 bit if optional)][value (1 bit)]
-    class DefaultBoolCodec : public TypedFixedFieldCodec<bool>
-    {
-      private:
-        Bitset encode(const bool& wire_value);
-        Bitset encode();
-        bool decode(Bitset* bits);
-        unsigned size();
-        void validate();
-    };
-        
-    /// \brief Provides an variable length ASCII string encoder. Can encode strings up to 255 bytes by using a length byte preceeding the string.
-    ///
-    /// [length of following string (1 byte)][string (0-255 bytes)]
-    class DefaultStringCodec : public TypedFieldCodec<std::string>
-    {
-      private:
-        Bitset encode();
-        Bitset encode(const std::string& wire_value);
-        std::string decode(Bitset* bits);
-        unsigned size();
-        unsigned size(const std::string& wire_value);
-        unsigned max_size();
-        unsigned min_size();
-        void validate();
-      private:
-        enum { MAX_STRING_LENGTH = 255 };
-            
-    };
-
-
-    /// \brief Provides an fixed length byte string encoder.        
-    class DefaultBytesCodec : public TypedFieldCodec<std::string>
-    {
-      private:
-        Bitset encode();
-        Bitset encode(const std::string& wire_value);
-        std::string decode(Bitset* bits);
-        unsigned size();
-        unsigned size(const std::string& wire_value);
-        unsigned max_size();
-        unsigned min_size();
-        void validate();
-    };
-
-    /// \brief Provides an enum encoder. This converts the enumeration to an integer (based on the enumeration <i>index</i> (<b>not</b> its <i>value</i>) and uses DefaultNumericFieldCodec to encode the integer.
-    class DefaultEnumCodec
-        : public DefaultNumericFieldCodec<int32, const google::protobuf::EnumValueDescriptor*>
-    {
-      public:
-        int32 pre_encode(const google::protobuf::EnumValueDescriptor* const& field_value);
-        const google::protobuf::EnumValueDescriptor* post_decode(const int32& wire_value);
-
-      private:
-        void validate() { }
-            
-        double max()
-        {
-            const google::protobuf::EnumDescriptor* e = this_field()->enum_type();
-            return e->value_count()-1;
-        }
-        double min()
-        { return 0; }
-    };
-        
-        
-    /// \brief Encodes time of day (default: second precision, but can be set with (dccl.field).precision extension) 
-    ///
-    /// \tparam TimeType A type representing time: See the various specializations of this class for allowed types.
-
-    typedef double time_wire_type;
-    template<typename TimeType, int conversion_factor>
-        class TimeCodecBase : public DefaultNumericFieldCodec<time_wire_type, TimeType>
-    {
-      public:
-        time_wire_type pre_encode(const TimeType& time_of_day) {
-            time_wire_type max_secs = max();
-            return std::fmod(time_of_day / static_cast<time_wire_type>(conversion_factor), max_secs);
-        }
-
-        TimeType post_decode(const time_wire_type& encoded_time) {
-
-            int64 max_secs = (int64)max();
-            timeval t;
-            gettimeofday(&t, 0);
-            int64 now = t.tv_sec;
-            int64 daystart = now - (now % max_secs);
-            int64 today_time = now - daystart;
-
-            // If time is more than 12 hours ahead of now, assume it's yesterday.
-            if ((encoded_time - today_time) > (max_secs/2)) {
-                daystart -= max_secs;
-            } else if ((today_time - encoded_time) > (max_secs/2)) {
-                daystart += max_secs;
-            }
-
-            return (TimeType)(conversion_factor * (daystart + encoded_time));
-        }
-
-      private:
-        void validate()
-        {
-            DefaultNumericFieldCodec<time_wire_type, TimeType>::validate_numeric_bounds();
-        }
-
-        double max() { 
-            return FieldCodecBase::dccl_field_options().num_days() * SECONDS_IN_DAY;
-        }
-
-        double min() { return 0; }
-        double precision() 
-        {
-            if(!FieldCodecBase::dccl_field_options().has_precision())
-                return 0; // default to second precision
-            else
-            {
-                return FieldCodecBase::dccl_field_options().precision() + (double)std::log10((double)conversion_factor);
-            }
-            
-        }
-        
-
-      private:
-        enum { SECONDS_IN_DAY = 86400 };
-    };
-    
-    template<typename TimeType>
-        class TimeCodec : public TimeCodecBase<TimeType, 0>
-    { BOOST_STATIC_ASSERT(sizeof(TimeCodec) == 0); };
-    
-    template<> class TimeCodec<uint64> : public TimeCodecBase<uint64, 1000000> { };
-    template<> class TimeCodec<int64> : public TimeCodecBase<int64, 1000000> { };
-    template<> class TimeCodec<double> : public TimeCodecBase<double, 1> { };
-    
-    
-    /// \brief Placeholder codec that takes no space on the wire (0 bits).
-    template<typename T>
-        class StaticCodec : public TypedFixedFieldCodec<T>
-    {
-        Bitset encode(const T&)
-        { return Bitset(size()); }
-
-        Bitset encode()
-        { return Bitset(size()); }
-
-        T decode(Bitset* bits)
-        {
-            return boost::lexical_cast<T>(
-                FieldCodecBase::dccl_field_options().static_value());
-        }
-            
-        unsigned size()
-        { return 0; }
-            
-        void validate()
-        {
-            FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_static_value(), "missing (dccl.field).static_value");
-
-            std::string t = FieldCodecBase::dccl_field_options().static_value();
-            try
-            {
-                boost::lexical_cast<T>(t);
-            }
-            catch(boost::bad_lexical_cast&)
-            {
-                FieldCodecBase::require(false, "invalid static_value for this type.");
-            }
-        }
-            
-    };
-        
+    namespace v2
+    {
+        /// \brief Provides a basic bounded arbitrary length numeric (double, float, uint32, uint64, int32, int64) encoder.
+        ///
+        /// Takes ceil(log2((max-min)*10^precision)+1) bits for required fields, ceil(log2((max-min)*10^precision)+2) for optional fields.
+        template<typename WireType, typename FieldType = WireType>
+            class DefaultNumericFieldCodec : public TypedFixedFieldCodec<WireType, FieldType>
+            {
+              protected:
+
+              virtual double max()
+              { return FieldCodecBase::dccl_field_options().max(); }
+      
+              virtual double min()
+              { return FieldCodecBase::dccl_field_options().min(); }
+
+              virtual double precision()
+              { return FieldCodecBase::dccl_field_options().precision(); }
+      
+              virtual void validate()
+              {
+                  FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_min(),
+                                          "missing (dccl.field).min");
+                  FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_max(),
+                                          "missing (dccl.field).max");
+
+                  validate_numeric_bounds();
+              }
+
+              void validate_numeric_bounds()
+              {
+
+                  // ensure given max and min fit within WireType ranges
+                  FieldCodecBase::require(min() >= boost::numeric::bounds<WireType>::lowest(),
+                                          "(dccl.field).min must be >= minimum of this field type.");
+                  FieldCodecBase::require(max() <= boost::numeric::bounds<WireType>::highest(),
+                                          "(dccl.field).max must be <= maximum of this field type.");
+
+          
+                  // ensure value fits into double
+                  FieldCodecBase::require((precision() + std::ceil(std::log10(max() - min()))) <= std::numeric_limits<double>::digits10,
+                                          "[(dccl.field).max-(dccl.field).min]*10^(dccl.field).precision must fit in a double-precision floating point value. Please increase min, decrease max, or decrease precision.");
+          
+              }
+      
+      
+              Bitset encode()
+              {
+                  return Bitset(size());
+              }
+          
+          
+              virtual Bitset encode(const WireType& value)
+              {
+                  // round first, before checking bounds
+                  WireType wire_value = dccl::round(value, precision());
+
+                  // check bounds, if out-of-bounds, send as zeros
+                  if(wire_value < min() || wire_value > max())
+                      return Bitset(size());
+          
+                  wire_value -= dccl::round((WireType)min(), precision());
+
+                  if (precision() < 0) {
+                      wire_value /= (WireType)std::pow(10.0, -precision());
+                  } else if (precision() > 0) {
+                      wire_value *= (WireType)std::pow(10.0, precision());
+                  }
+
+                  dccl::uint64 uint_value = boost::numeric_cast<dccl::uint64>(dccl::round(wire_value, 0));
+
+                  // "presence" value (0)
+                  if(!FieldCodecBase::this_field()->is_required())
+                      uint_value += 1;
+	  
+
+                  Bitset encoded;
+                  encoded.from(uint_value, size());
+                  return encoded;
+              }
+          
+              virtual WireType decode(Bitset* bits)
+              {
+                  // The line below SHOULD BE:
+                  // dccl::uint64 t = bits->to<dccl::uint64>();
+                  // But GCC3.3 requires an explicit template modifier on the method.
+                  // See, e.g., http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10959
+                  dccl::uint64 uint_value = (bits->template to<dccl::uint64>)();
+
+                  if(!FieldCodecBase::this_field()->is_required())
+                  {
+                      if(!uint_value) throw NullValueException();
+                      --uint_value;
+                  }
+	  
+                  WireType wire_value = (WireType)uint_value;
+
+                  if (precision() < 0) {
+                      wire_value *= (WireType)std::pow(10.0, -precision());
+                  } else if (precision() > 0) {
+                      wire_value /= (WireType)std::pow(10.0, precision());
+                  }
+
+                  // round values again to properly handle cases where double precision
+                  // leads to slightly off values (e.g. 2.099999999 instead of 2.1)
+                  wire_value = dccl::round(wire_value + dccl::round((WireType)min(), precision()),
+                                           precision());
+
+                  return wire_value;
+              }
+
+              unsigned size()
+              {
+                  // if not required field, leave one value for unspecified (always encoded as 0)
+                  const unsigned NULL_VALUE = FieldCodecBase::this_field()->is_required() ? 0 : 1;
+              
+                  return dccl::ceil_log2((max()-min())*std::pow(10.0, precision())+1 + NULL_VALUE);
+              }
+            
+            };
+
+        /// \brief Provides a bool encoder. Uses 1 bit if field is `required`, 2 bits if `optional`
+        ///
+        /// [presence bit (0 bits if required, 1 bit if optional)][value (1 bit)]
+        class DefaultBoolCodec : public TypedFixedFieldCodec<bool>
+        {
+          private:
+            Bitset encode(const bool& wire_value);
+            Bitset encode();
+            bool decode(Bitset* bits);
+            unsigned size();
+            void validate();
+        };
+        
+        /// \brief Provides an variable length ASCII string encoder. Can encode strings up to 255 bytes by using a length byte preceeding the string.
+        ///
+        /// [length of following string (1 byte)][string (0-255 bytes)]
+        class DefaultStringCodec : public TypedFieldCodec<std::string>
+        {
+          private:
+            Bitset encode();
+            Bitset encode(const std::string& wire_value);
+            std::string decode(Bitset* bits);
+            unsigned size();
+            unsigned size(const std::string& wire_value);
+            unsigned max_size();
+            unsigned min_size();
+            void validate();
+          private:
+            enum { MAX_STRING_LENGTH = 255 };
+            
+        };
+
+
+        /// \brief Provides an fixed length byte string encoder.        
+        class DefaultBytesCodec : public TypedFieldCodec<std::string>
+        {
+          private:
+            Bitset encode();
+            Bitset encode(const std::string& wire_value);
+            std::string decode(Bitset* bits);
+            unsigned size();
+            unsigned size(const std::string& wire_value);
+            unsigned max_size();
+            unsigned min_size();
+            void validate();
+        };
+
+        /// \brief Provides an enum encoder. This converts the enumeration to an integer (based on the enumeration <i>index</i> (<b>not</b> its <i>value</i>) and uses DefaultNumericFieldCodec to encode the integer.
+        class DefaultEnumCodec
+            : public DefaultNumericFieldCodec<int32, const google::protobuf::EnumValueDescriptor*>
+        {
+          public:
+            int32 pre_encode(const google::protobuf::EnumValueDescriptor* const& field_value);
+            const google::protobuf::EnumValueDescriptor* post_decode(const int32& wire_value);
+
+          private:
+            void validate() { }
+            
+            double max()
+            {
+                const google::protobuf::EnumDescriptor* e = this_field()->enum_type();
+                return e->value_count()-1;
+            }
+            double min()
+            { return 0; }
+        };
+        
+        
+        /// \brief Encodes time of day (default: second precision, but can be set with (dccl.field).precision extension) 
+        ///
+        /// \tparam TimeType A type representing time: See the various specializations of this class for allowed types.
+
+        typedef double time_wire_type;
+        template<typename TimeType, int conversion_factor>
+            class TimeCodecBase : public DefaultNumericFieldCodec<time_wire_type, TimeType>
+        {
+          public:
+            time_wire_type pre_encode(const TimeType& time_of_day) {
+                time_wire_type max_secs = max();
+                return std::fmod(time_of_day / static_cast<time_wire_type>(conversion_factor), max_secs);
+            }
+
+            TimeType post_decode(const time_wire_type& encoded_time) {
+
+                int64 max_secs = (int64)max();
+                timeval t;
+                gettimeofday(&t, 0);
+                int64 now = t.tv_sec;
+                int64 daystart = now - (now % max_secs);
+                int64 today_time = now - daystart;
+
+                // If time is more than 12 hours ahead of now, assume it's yesterday.
+                if ((encoded_time - today_time) > (max_secs/2)) {
+                    daystart -= max_secs;
+                } else if ((today_time - encoded_time) > (max_secs/2)) {
+                    daystart += max_secs;
+                }
+
+                return (TimeType)(conversion_factor * (daystart + encoded_time));
+            }
+
+          private:
+            void validate()
+            {
+                DefaultNumericFieldCodec<time_wire_type, TimeType>::validate_numeric_bounds();
+            }
+
+            double max() { 
+                return FieldCodecBase::dccl_field_options().num_days() * SECONDS_IN_DAY;
+            }
+
+            double min() { return 0; }
+            double precision() 
+            {
+                if(!FieldCodecBase::dccl_field_options().has_precision())
+                    return 0; // default to second precision
+                else
+                {
+                    return FieldCodecBase::dccl_field_options().precision() + (double)std::log10((double)conversion_factor);
+                }
+            
+            }
+        
+
+          private:
+            enum { SECONDS_IN_DAY = 86400 };
+        };
+    
+        template<typename TimeType>
+            class TimeCodec : public TimeCodecBase<TimeType, 0>
+        { BOOST_STATIC_ASSERT(sizeof(TimeCodec) == 0); };
+    
+        template<> class TimeCodec<uint64> : public TimeCodecBase<uint64, 1000000> { };
+        template<> class TimeCodec<int64> : public TimeCodecBase<int64, 1000000> { };
+        template<> class TimeCodec<double> : public TimeCodecBase<double, 1> { };
+    
+    
+        /// \brief Placeholder codec that takes no space on the wire (0 bits).
+        template<typename T>
+            class StaticCodec : public TypedFixedFieldCodec<T>
+        {
+            Bitset encode(const T&)
+            { return Bitset(size()); }
+
+            Bitset encode()
+            { return Bitset(size()); }
+
+            T decode(Bitset* bits)
+            {
+                return boost::lexical_cast<T>(
+                    FieldCodecBase::dccl_field_options().static_value());
+            }
+            
+            unsigned size()
+            { return 0; }
+            
+            void validate()
+            {
+                FieldCodecBase::require(FieldCodecBase::dccl_field_options().has_static_value(), "missing (dccl.field).static_value");
+
+                std::string t = FieldCodecBase::dccl_field_options().static_value();
+                try
+                {
+                    boost::lexical_cast<T>(t);
+                }
+                catch(boost::bad_lexical_cast&)
+                {
+                    FieldCodecBase::require(false, "invalid static_value for this type.");
+                }
+            }
+            
+        };
+    }
 }
 
 

=== renamed file 'src/field_codec_default_message.cpp' => 'src/codecs2/field_codec_default_message.cpp'
--- src/field_codec_default_message.cpp	2014-04-22 20:10:37 +0000
+++ src/codecs2/field_codec_default_message.cpp	2014-08-27 16:27:22 +0000
@@ -30,17 +30,17 @@
 // DefaultMessageCodec
 //
 
-void dccl::DefaultMessageCodec::any_encode(Bitset* bits, const boost::any& wire_value)
+void dccl::v2::DefaultMessageCodec::any_encode(Bitset* bits, const boost::any& wire_value)
 {
-  if(wire_value.empty())
-      *bits = Bitset(min_size());
-  else
-      *bits = traverse_const_message<Encoder, Bitset>(wire_value);
+    if(wire_value.empty())
+        *bits = Bitset(min_size());
+    else
+        *bits = traverse_const_message<Encoder, Bitset>(wire_value);
 }
   
 
  
-unsigned dccl::DefaultMessageCodec::any_size(const boost::any& wire_value)
+unsigned dccl::v2::DefaultMessageCodec::any_size(const boost::any& wire_value)
 {
     if(wire_value.empty())
         return min_size();
@@ -49,7 +49,7 @@
 }
 
 
-void dccl::DefaultMessageCodec::any_decode(Bitset* bits, boost::any* wire_value)
+void dccl::v2::DefaultMessageCodec::any_decode(Bitset* bits, boost::any* wire_value)
 {
     try
     {
@@ -67,8 +67,8 @@
             if(!check_field(field_desc))
                 continue;
 
-            boost::shared_ptr<FieldCodecBase> codec =
-                FieldCodecManager::find(field_desc);
+            
+            boost::shared_ptr<FieldCodecBase> codec = find(field_desc);            
             boost::shared_ptr<FromProtoCppTypeBase> helper =
                 TypeHelper::find(field_desc);
 
@@ -127,14 +127,14 @@
 }
 
 
-unsigned dccl::DefaultMessageCodec::max_size()
+unsigned dccl::v2::DefaultMessageCodec::max_size()
 {
     unsigned u = 0;
     traverse_descriptor<MaxSize>(&u);
     return u;
 }
 
-unsigned dccl::DefaultMessageCodec::min_size()
+unsigned dccl::v2::DefaultMessageCodec::min_size()
 {
     unsigned u = 0;
     traverse_descriptor<MinSize>(&u);
@@ -142,20 +142,20 @@
 }
 
 
-void dccl::DefaultMessageCodec::validate()
+void dccl::v2::DefaultMessageCodec::validate()
 {
     bool b = false;
     traverse_descriptor<Validate>(&b);
 }
 
-std::string dccl::DefaultMessageCodec::info()
+std::string dccl::v2::DefaultMessageCodec::info()
 {
     std::stringstream ss;
     traverse_descriptor<Info>(&ss);
     return ss.str();
 }
 
-bool dccl::DefaultMessageCodec::check_field(const google::protobuf::FieldDescriptor* field)
+bool dccl::v2::DefaultMessageCodec::check_field(const google::protobuf::FieldDescriptor* field)
 {
     if(!field)
     {
@@ -171,7 +171,7 @@
         else if(MessageStack::current_part() == MessageStack::UNKNOWN) // part not yet explicitly specified
         {
             if(field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE &&
-               FieldCodecManager::find(field)->name() == Codec::default_codec_name()) // default message codec will expand
+               find(field)->name() == Codec::default_codec_name()) // default message codec will expand
                 return true;
             else if((part() == MessageStack::HEAD && !dccl_field_options.in_head())
                     || (part() == MessageStack::BODY && dccl_field_options.in_head()))

=== renamed file 'src/field_codec_default_message.h' => 'src/codecs2/field_codec_default_message.h'
--- src/field_codec_default_message.h	2014-04-22 20:10:37 +0000
+++ src/codecs2/field_codec_default_message.h	2014-08-27 16:27:22 +0000
@@ -24,225 +24,183 @@
 #ifndef DCCLFIELDCODECDEFAULTMESSAGE20110510H
 #define DCCLFIELDCODECDEFAULTMESSAGE20110510H
 
-#include "field_codec.h"
-#include "field_codec_manager.h"
+#include "dccl/field_codec.h"
+#include "dccl/field_codec_manager.h"
 
 #include "dccl/protobuf/option_extensions.pb.h"
 
 namespace dccl
 {
-    /// \brief Provides the default codec for encoding a base Google Protobuf message or an embedded message by calling the appropriate field codecs for every field.
-    class DefaultMessageCodec : public FieldCodecBase
+    namespace v2
     {
-      private:
-            
-        void any_encode(Bitset* bits, const boost::any& wire_value);
-        void any_decode(Bitset* bits, boost::any* wire_value); 
-        unsigned max_size();
-        unsigned min_size();
-        unsigned any_size(const boost::any& wire_value);
-
-            
-        void validate();
-        std::string info();
-        bool check_field(const google::protobuf::FieldDescriptor* field);
-
-        struct Size
-        {
-            static void repeated(boost::shared_ptr<FieldCodecBase> codec,
-                                 unsigned* return_value,
-                                 const std::vector<boost::any>& field_values,
-                                 const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_size_repeated(return_value, field_values, field_desc);
-                }
-                
-            static void single(boost::shared_ptr<FieldCodecBase> codec,
-                               unsigned* return_value,
-                               const boost::any& field_value,
-                               const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_size(return_value, field_value, field_desc);
-                }
-                
-        };
-            
-        struct Encoder
-        {
-            static void repeated(boost::shared_ptr<FieldCodecBase> codec,
-                                 Bitset* return_value,
-                                 const std::vector<boost::any>& field_values,
-                                 const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_encode_repeated(return_value, field_values, field_desc);
-                }
-                
-            static void single(boost::shared_ptr<FieldCodecBase> codec,
-                               Bitset* return_value,
-                               const boost::any& field_value,
-                               const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_encode(return_value, field_value, field_desc);
-                }
-        };
-
-        struct MaxSize
-        {
-            static void field(boost::shared_ptr<FieldCodecBase> codec,
-                              unsigned* return_value,
-                              const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_max_size(return_value, field_desc);
-                }
-        };
-
-        struct MinSize
-        {
-            static void field(boost::shared_ptr<FieldCodecBase> codec,
-                              unsigned* return_value,
-                              const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_min_size(return_value, field_desc);
-                }
-        };
-            
-            
-        struct Validate
-        {
-            static void field(boost::shared_ptr<FieldCodecBase> codec,
-                              bool* return_value,
-                              const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_validate(return_value, field_desc);
-                }
-        };
-
-        struct Info
-        {
-            static void field(boost::shared_ptr<FieldCodecBase> codec,
-                              std::stringstream* return_value,
-                              const google::protobuf::FieldDescriptor* field_desc)
-                {
-                    codec->field_info(return_value, field_desc);
-                }
-        };
-            
-            
-        template<typename Action, typename ReturnType>
-            void traverse_descriptor(ReturnType* return_value)
-        {
-            const google::protobuf::Descriptor* desc =
-                FieldCodecBase::this_descriptor();
-            for(int i = 0, n = desc->field_count(); i < n; ++i)
-            {
-                const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
+        /// \brief Provides the default codec for encoding a base Google Protobuf message or an embedded message by calling the appropriate field codecs for every field.
+        class DefaultMessageCodec : public FieldCodecBase
+        {
+          private:
+            
+            void any_encode(Bitset* bits, const boost::any& wire_value);
+            void any_decode(Bitset* bits, boost::any* wire_value); 
+            unsigned max_size();
+            unsigned min_size();
+            unsigned any_size(const boost::any& wire_value);
+
+
+            boost::shared_ptr<FieldCodecBase> find(const google::protobuf::FieldDescriptor* field_desc)
+            {
+                return FieldCodecManager::find(field_desc, has_codec_group(), codec_group());
+            }
+        
+        
+            void validate();
+            std::string info();
+            bool check_field(const google::protobuf::FieldDescriptor* field);
+
+            struct Size
+            {
+                static void repeated(boost::shared_ptr<FieldCodecBase> codec,
+                                     unsigned* return_value,
+                                     const std::vector<boost::any>& field_values,
+                                     const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_size_repeated(return_value, field_values, field_desc);
+                    }
+                
+                static void single(boost::shared_ptr<FieldCodecBase> codec,
+                                   unsigned* return_value,
+                                   const boost::any& field_value,
+                                   const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_size(return_value, field_value, field_desc);
+                    }
+                
+            };
+            
+            struct Encoder
+            {
+                static void repeated(boost::shared_ptr<FieldCodecBase> codec,
+                                     Bitset* return_value,
+                                     const std::vector<boost::any>& field_values,
+                                     const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_encode_repeated(return_value, field_values, field_desc);
+                    }
+                
+                static void single(boost::shared_ptr<FieldCodecBase> codec,
+                                   Bitset* return_value,
+                                   const boost::any& field_value,
+                                   const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_encode(return_value, field_value, field_desc);
+                    }
+            };
+
+            struct MaxSize
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  unsigned* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_max_size(return_value, field_desc);
+                    }
+            };
+
+            struct MinSize
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  unsigned* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_min_size(return_value, field_desc);
+                    }
+            };
+            
+            
+            struct Validate
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  bool* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_validate(return_value, field_desc);
+                    }
+            };
+
+            struct Info
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  std::stringstream* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_info(return_value, field_desc);
+                    }
+            };
+            
+            
+            template<typename Action, typename ReturnType>
+                void traverse_descriptor(ReturnType* return_value)
+            {
+                const google::protobuf::Descriptor* desc =
+                    FieldCodecBase::this_descriptor();
+                for(int i = 0, n = desc->field_count(); i < n; ++i)
+                {
+                    const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
                     
-                if(!check_field(field_desc))
-                    continue;
+                    if(!check_field(field_desc))
+                        continue;
 
-                Action::field(FieldCodecManager::find(field_desc),
-                              return_value, field_desc);                    
+                    Action::field(find(field_desc), return_value, field_desc);                    
+                }
             }
-        }
             
 
-        template<typename Action, typename ReturnType>
-            ReturnType traverse_const_message(const boost::any& wire_value)
-        {
-            try
+            template<typename Action, typename ReturnType>
+                ReturnType traverse_const_message(const boost::any& wire_value)
             {
-                ReturnType return_value = ReturnType();
+                try
+                {
+                    ReturnType return_value = ReturnType();
        
-                const google::protobuf::Message* msg = boost::any_cast<const google::protobuf::Message*>(wire_value);
-                const google::protobuf::Descriptor* desc = msg->GetDescriptor();
-                const google::protobuf::Reflection* refl = msg->GetReflection();
-                for(int i = 0, n = desc->field_count(); i < n; ++i)
-                {       
-                    const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
+                    const google::protobuf::Message* msg = boost::any_cast<const google::protobuf::Message*>(wire_value);
+                    const google::protobuf::Descriptor* desc = msg->GetDescriptor();
+                    const google::protobuf::Reflection* refl = msg->GetReflection();
+                    for(int i = 0, n = desc->field_count(); i < n; ++i)
+                    {       
+                        const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
 
-                    if(!check_field(field_desc))
-                        continue;
+                        if(!check_field(field_desc))
+                            continue;
            
-                    boost::shared_ptr<FieldCodecBase> codec =
-                        FieldCodecManager::find(field_desc);
-                    boost::shared_ptr<FromProtoCppTypeBase> helper =
-                        TypeHelper::find(field_desc);
-            
-            
-                    if(field_desc->is_repeated())
-                    {
-                        std::vector<boost::any> field_values;
-                        for(int j = 0, m = refl->FieldSize(*msg, field_desc); j < m; ++j)
-                            field_values.push_back(helper->get_repeated_value(field_desc, *msg, j));
+                        boost::shared_ptr<FieldCodecBase> codec = find(field_desc);
+                        boost::shared_ptr<FromProtoCppTypeBase> helper =
+                            TypeHelper::find(field_desc);
+            
+            
+                        if(field_desc->is_repeated())
+                        {
+                            std::vector<boost::any> field_values;
+                            for(int j = 0, m = refl->FieldSize(*msg, field_desc); j < m; ++j)
+                                field_values.push_back(helper->get_repeated_value(field_desc, *msg, j));
                    
-                        Action::repeated(codec, &return_value, field_values, field_desc);
-                    }
-                    else
-                    {
-                        Action::single(codec, &return_value, helper->get_value(field_desc, *msg), field_desc);
-                    }
-                }
-                return return_value;
-            }
-            catch(boost::bad_any_cast& e)
-            {
-                throw(Exception("Bad type given to traverse const, expecting const google::protobuf::Message*, got " + std::string(wire_value.type().name())));
-            }
-                
-        }
-
-        template<typename Action, typename ReturnType>
-            ReturnType traverse_mutable_message(const boost::any& wire_value)
-        {
-            try
-            {
-                ReturnType return_value = ReturnType();
-       
-                const google::protobuf::Message* msg = boost::any_cast<const google::protobuf::Message*>(wire_value);
-                const google::protobuf::Descriptor* desc = msg->GetDescriptor();
-                const google::protobuf::Reflection* refl = msg->GetReflection();
-                for(int i = 0, n = desc->field_count(); i < n; ++i)
-                {       
-                    const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
-
-                    if(!check_field(field_desc))
-                        continue;
-           
-                    boost::shared_ptr<FieldCodecBase> codec =
-                        FieldCodecManager::find(field_desc);
-                    boost::shared_ptr<FromProtoCppTypeBase> helper =
-                        TypeHelper::find(field_desc);
-            
-            
-                    if(field_desc->is_repeated())
-                    {
-                        std::vector<boost::any> field_values;
-                        for(int j = 0, m = refl->FieldSize(*msg, field_desc); j < m; ++j)
-                            field_values.push_back(helper->get_repeated_value(field_desc, *msg, j));
-                            
-                        Action::repeated(codec, &return_value, field_values, field_desc);
-                    }
-                    else
-                    {
-                        Action::single(codec, &return_value, helper->get_value(field_desc, *msg), field_desc);
-                    }
-                }
-                return return_value;
-            }
-            catch(boost::bad_any_cast& e)
-            {
-                throw(Exception("Bad type given to traverse, expecting const google::protobuf::Message*"));
-            }
-                
-        }
-
-            
-
-    };
-
+                            Action::repeated(codec, &return_value, field_values, field_desc);
+                        }
+                        else
+                        {
+                            Action::single(codec, &return_value, helper->get_value(field_desc, *msg), field_desc);
+                        }
+                    }
+                    return return_value;
+                }
+                catch(boost::bad_any_cast& e)
+                {
+                    throw(Exception("Bad type given to traverse const, expecting const google::protobuf::Message*, got " + std::string(wire_value.type().name())));
+                }
+                
+            }
+        };
+
+    }
 }
 
-
 //encode, size, etc.
 
 

=== added directory 'src/codecs3'
=== added file 'src/codecs3/field_codec_default.cpp'
--- src/codecs3/field_codec_default.cpp	1970-01-01 00:00:00 +0000
+++ src/codecs3/field_codec_default.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,122 @@
+// Copyright 2009-2014 Toby Schneider (https://launchpad.net/~tes)
+//                     GobySoft, LLC (2013-)
+//                     Massachusetts Institute of Technology (2007-2014)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 2.1 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "dccl/codecs3/field_codec_default.h"
+
+using namespace dccl::logger;
+
+//
+// DefaultStringCodec
+//
+
+dccl::Bitset dccl::v3::DefaultStringCodec::encode()
+{
+    return Bitset(min_size());
+}
+
+dccl::Bitset dccl::v3::DefaultStringCodec::encode(const std::string& wire_value)
+{
+    std::string s = wire_value;
+    if(s.size() > dccl_field_options().max_length())
+    {
+        dccl::dlog.is(DEBUG2) && dccl::dlog << "String " << s <<  " exceeds `dccl.max_length`, truncating" << std::endl;
+        s.resize(dccl_field_options().max_length()); 
+    }
+        
+            
+    Bitset value_bits;
+    value_bits.from_byte_string(s);
+    
+    Bitset length_bits(min_size(), s.length());
+
+    dccl::dlog.is(DEBUG2) && dccl::dlog << "DefaultStringCodec value_bits: " << value_bits << std::endl;    
+
+    
+    dccl::dlog.is(DEBUG2) && dccl::dlog << "DefaultStringCodec length_bits: " << length_bits << std::endl;    
+    
+    // adds to MSBs
+    for(int i = 0, n = value_bits.size(); i < n; ++i)
+        length_bits.push_back(value_bits[i]);
+
+    dccl::dlog.is(DEBUG2) && dccl::dlog << "DefaultStringCodec created: " << length_bits << std::endl;
+    
+    
+    return length_bits;
+}
+
+std::string dccl::v3::DefaultStringCodec::decode(Bitset* bits)
+{
+    unsigned value_length = bits->to_ulong();
+    
+    if(value_length)
+    {
+        
+        unsigned header_length = min_size();
+        
+        dccl::dlog.is(DEBUG2) && dccl::dlog << "Length of string is = " << value_length << std::endl;
+        
+        dccl::dlog.is(DEBUG2) && dccl::dlog << "bits before get_more_bits " << *bits << std::endl;    
+
+        // grabs more bits to add to the MSBs of `bits`
+        bits->get_more_bits(value_length*BITS_IN_BYTE);
+
+        
+        dccl::dlog.is(DEBUG2) && dccl::dlog << "bits after get_more_bits " << *bits << std::endl;    
+        Bitset string_body_bits = *bits;
+        string_body_bits >>= header_length;
+        string_body_bits.resize(bits->size() - header_length);
+    
+        return string_body_bits.to_byte_string();
+    }
+    else
+    {
+        throw NullValueException();
+    }
+    
+}
+
+unsigned dccl::v3::DefaultStringCodec::size()
+{
+    return min_size();
+}
+
+unsigned dccl::v3::DefaultStringCodec::size(const std::string& wire_value)
+{
+    return std::min(min_size() + static_cast<unsigned>(wire_value.length()*BITS_IN_BYTE), max_size());
+}
+
+
+unsigned dccl::v3::DefaultStringCodec::max_size()
+{
+    // string length + actual string
+    return min_size() + dccl_field_options().max_length() * BITS_IN_BYTE;
+}
+
+unsigned dccl::v3::DefaultStringCodec::min_size()
+{
+    return dccl::ceil_log2(dccl_field_options().max_length()+1);
+}
+
+
+void dccl::v3::DefaultStringCodec::validate()
+{
+    require(dccl_field_options().has_max_length(), "missing (dccl.field).max_length");
+}

=== added file 'src/codecs3/field_codec_default.h'
--- src/codecs3/field_codec_default.h	1970-01-01 00:00:00 +0000
+++ src/codecs3/field_codec_default.h	2014-08-27 16:27:22 +0000
@@ -0,0 +1,77 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+// implements FieldCodecBase for all the basic DCCL types for version 3
+
+#ifndef DCCLV3FIELDCODECDEFAULT20140403H
+#define DCCLV3FIELDCODECDEFAULT20140403H
+
+#include "dccl/codecs2/field_codec_default.h"
+
+namespace dccl
+{
+    namespace v3
+    {
+	// all these are the same as version 2
+        template<typename WireType, typename FieldType = WireType>
+            class DefaultNumericFieldCodec : public v2::DefaultNumericFieldCodec<WireType, FieldType> { };
+
+	typedef v2::DefaultBoolCodec DefaultBoolCodec;
+	typedef v2::DefaultBytesCodec DefaultBytesCodec;
+        typedef v2::DefaultEnumCodec DefaultEnumCodec;
+
+        
+        template<typename TimeType>
+            class TimeCodec : public v2::TimeCodecBase<TimeType, 0>
+        { BOOST_STATIC_ASSERT(sizeof(TimeCodec) == 0); };
+
+        template<> class TimeCodec<uint64> : public v2::TimeCodecBase<uint64, 1000000> { };
+        template<> class TimeCodec<int64> : public v2::TimeCodecBase<int64, 1000000> { };
+        template<> class TimeCodec<double> : public v2::TimeCodecBase<double, 1> { };
+    
+        template<typename T>
+            class StaticCodec : public v2::StaticCodec<T>
+        { };
+
+
+        /// \brief Provides an variable length ASCII string encoder.
+        ///
+        /// [length of following string size: ceil(log2(max_length))][string]
+        class DefaultStringCodec : public TypedFieldCodec<std::string>
+        {
+          private:
+            Bitset encode();
+            Bitset encode(const std::string& wire_value);
+            std::string decode(Bitset* bits);
+            unsigned size();
+            unsigned size(const std::string& wire_value);
+            unsigned max_size();
+            unsigned min_size();
+            void validate();
+        };
+
+    }
+}
+
+#endif

=== added file 'src/codecs3/field_codec_default_message.cpp'
--- src/codecs3/field_codec_default_message.cpp	1970-01-01 00:00:00 +0000
+++ src/codecs3/field_codec_default_message.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,236 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+#include "dccl/codec.h"
+#include "dccl/codecs3/field_codec_default_message.h"
+
+using dccl::dlog;
+
+//
+// DefaultMessageCodec
+//
+
+void dccl::v3::DefaultMessageCodec::any_encode(Bitset* bits, const boost::any& wire_value)
+{    
+    if(wire_value.empty())
+    {
+        *bits = Bitset(min_size());
+    }
+    else
+    {
+        *bits = traverse_const_message<Encoder, Bitset>(wire_value);
+        
+        if(is_optional())
+            bits->push_front(true); // presence bit
+        
+    }  
+}
+  
+
+ 
+unsigned dccl::v3::DefaultMessageCodec::any_size(const boost::any& wire_value)
+{
+    if(wire_value.empty())
+    {
+        return min_size();
+    }
+    else
+    {
+        unsigned size = traverse_const_message<Size, unsigned>(wire_value);
+        if(is_optional())
+        {
+            const unsigned presence_bit = 1;
+            size += presence_bit;
+        }
+        
+        return size;
+    }
+}
+
+
+void dccl::v3::DefaultMessageCodec::any_decode(Bitset* bits, boost::any* wire_value)
+{
+    try
+    {
+        
+        google::protobuf::Message* msg = boost::any_cast<google::protobuf::Message* >(*wire_value);
+
+        if(is_optional())      
+        {
+            if(!bits->to_ulong())
+            {
+                *wire_value = boost::any();
+                return;
+            }
+            else
+            {
+                bits->pop_front(); // presence bit
+            }
+        }        
+        
+        const google::protobuf::Descriptor* desc = msg->GetDescriptor();
+        const google::protobuf::Reflection* refl = msg->GetReflection();
+        
+        for(int i = 0, n = desc->field_count(); i < n; ++i)
+        {
+        
+            const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
+
+            if(!check_field(field_desc))
+                continue;
+
+            
+            boost::shared_ptr<FieldCodecBase> codec = find(field_desc);            
+            boost::shared_ptr<FromProtoCppTypeBase> helper =
+                TypeHelper::find(field_desc);
+
+            if(field_desc->is_repeated())
+            {   
+                std::vector<boost::any> field_values;
+                if(field_desc->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+                {
+                    unsigned max_repeat = field_desc->options().GetExtension(dccl::field).max_repeat();
+                    for(unsigned j = 0, m = max_repeat; j < m; ++j)
+                        field_values.push_back(refl->AddMessage(msg, field_desc));
+
+                    codec->field_decode_repeated(bits, &field_values, field_desc);
+
+                    // remove the unused messages
+                    for(int j = field_values.size(), m = max_repeat; j < m; ++j)
+                    {
+                        refl->RemoveLast(msg, field_desc);
+                    }
+                }
+                else
+                {
+                    // for primitive types
+                    codec->field_decode_repeated(bits, &field_values, field_desc);
+                    for(int j = 0, m = field_values.size(); j < m; ++j)
+                        helper->add_value(field_desc, msg, field_values[j]);
+                }
+            }
+            else
+            {
+                boost::any field_value;
+                if(field_desc->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+                {
+                    // allows us to propagate pointers instead of making many copies of entire messages
+                    field_value = refl->MutableMessage(msg, field_desc);
+                    codec->field_decode(bits, &field_value, field_desc);
+                    if(field_value.empty()) refl->ClearField(msg, field_desc);    
+                }
+                else
+                {
+                    // for primitive types
+                    codec->field_decode(bits, &field_value, field_desc);
+                    helper->set_value(field_desc, msg, field_value);
+                }
+            } 
+        }
+
+        std::vector< const google::protobuf::FieldDescriptor* > set_fields;
+        refl->ListFields(*msg, &set_fields);
+        if(set_fields.empty() && this_field()) *wire_value = boost::any();
+        else *wire_value = msg;
+    }
+    catch(boost::bad_any_cast& e)
+    {
+        throw(Exception("Bad type given to traverse mutable, expecting google::protobuf::Message*, got " + std::string(wire_value->type().name())));
+    }
+
+}
+
+
+unsigned dccl::v3::DefaultMessageCodec::max_size()
+{
+    unsigned u = 0;
+    traverse_descriptor<MaxSize>(&u);
+
+    if(is_optional())
+    {
+        const unsigned presence_bit = 1;
+        u += presence_bit;
+    }
+    
+    return u;
+}
+
+unsigned dccl::v3::DefaultMessageCodec::min_size()
+{
+    if(is_optional())
+    {
+        const unsigned presence_bit = 1;
+        return presence_bit;
+    }
+    else
+    {
+        unsigned u = 0;
+        traverse_descriptor<MinSize>(&u);
+        return u;
+    }
+}
+
+
+void dccl::v3::DefaultMessageCodec::validate()
+{
+    bool b = false;
+    traverse_descriptor<Validate>(&b);
+}
+
+std::string dccl::v3::DefaultMessageCodec::info()
+{
+    std::stringstream ss;
+    traverse_descriptor<Info>(&ss);
+    return ss.str();
+}
+
+bool dccl::v3::DefaultMessageCodec::check_field(const google::protobuf::FieldDescriptor* field)
+{
+    if(!field)
+    {
+        return true;
+    }
+    else
+    {
+        dccl::DCCLFieldOptions dccl_field_options = field->options().GetExtension(dccl::field);
+        if(dccl_field_options.omit()) // omit
+        {
+            return false;
+        }
+        else if(MessageStack::current_part() == MessageStack::UNKNOWN) // part not yet explicitly specified
+        {
+            if((part() == MessageStack::HEAD && !dccl_field_options.in_head())
+               || (part() == MessageStack::BODY && dccl_field_options.in_head()))
+                return false;
+            else
+                return true;
+        }
+        else if(MessageStack::current_part() != part()) // part specified and doesn't match
+            return false;
+        else
+            return true;
+    }    
+}
+
+

=== added file 'src/codecs3/field_codec_default_message.h'
--- src/codecs3/field_codec_default_message.h	1970-01-01 00:00:00 +0000
+++ src/codecs3/field_codec_default_message.h	2014-08-27 16:27:22 +0000
@@ -0,0 +1,213 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+#ifndef DCCLFIELDCODECDEFAULTMESSAGEV320140421H
+#define DCCLFIELDCODECDEFAULTMESSAGEV320140421H
+
+#include "dccl/field_codec.h"
+#include "dccl/field_codec_manager.h"
+
+#include "dccl/protobuf/option_extensions.pb.h"
+
+namespace dccl
+{
+    namespace v3
+    {
+        /// \brief Provides the default codec for encoding a base Google Protobuf message or an embedded message by calling the appropriate field codecs for every field.
+        class DefaultMessageCodec : public FieldCodecBase
+        {
+          private:
+            
+            void any_encode(Bitset* bits, const boost::any& wire_value);
+            void any_decode(Bitset* bits, boost::any* wire_value); 
+            unsigned max_size();
+            unsigned min_size();
+            unsigned any_size(const boost::any& wire_value);
+
+
+            boost::shared_ptr<FieldCodecBase> find(const google::protobuf::FieldDescriptor* field_desc)
+            {
+                return FieldCodecManager::find(field_desc, has_codec_group(), codec_group());
+            }
+        
+            bool is_optional()
+            { return this_field() && this_field()->is_optional(); }
+            
+            
+            void validate();
+            std::string info();
+            bool check_field(const google::protobuf::FieldDescriptor* field);
+
+            struct Size
+            {
+                static void repeated(boost::shared_ptr<FieldCodecBase> codec,
+                                     unsigned* return_value,
+                                     const std::vector<boost::any>& field_values,
+                                     const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_size_repeated(return_value, field_values, field_desc);
+                    }
+                
+                static void single(boost::shared_ptr<FieldCodecBase> codec,
+                                   unsigned* return_value,
+                                   const boost::any& field_value,
+                                   const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_size(return_value, field_value, field_desc);
+                    }
+                
+            };
+            
+            struct Encoder
+            {
+                static void repeated(boost::shared_ptr<FieldCodecBase> codec,
+                                     Bitset* return_value,
+                                     const std::vector<boost::any>& field_values,
+                                     const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_encode_repeated(return_value, field_values, field_desc);
+                    }
+                
+                static void single(boost::shared_ptr<FieldCodecBase> codec,
+                                   Bitset* return_value,
+                                   const boost::any& field_value,
+                                   const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_encode(return_value, field_value, field_desc);
+                    }
+            };
+
+            struct MaxSize
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  unsigned* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_max_size(return_value, field_desc);
+                    }
+            };
+
+            struct MinSize
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  unsigned* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_min_size(return_value, field_desc);
+                    }
+            };
+            
+            
+            struct Validate
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  bool* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_validate(return_value, field_desc);
+                    }
+            };
+
+            struct Info
+            {
+                static void field(boost::shared_ptr<FieldCodecBase> codec,
+                                  std::stringstream* return_value,
+                                  const google::protobuf::FieldDescriptor* field_desc)
+                    {
+                        codec->field_info(return_value, field_desc);
+                    }
+            };
+            
+            
+            template<typename Action, typename ReturnType>
+                void traverse_descriptor(ReturnType* return_value)
+            {
+                const google::protobuf::Descriptor* desc =
+                    FieldCodecBase::this_descriptor();
+                for(int i = 0, n = desc->field_count(); i < n; ++i)
+                {
+                    const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
+                    
+                    if(!check_field(field_desc))
+                        continue;
+
+                    Action::field(find(field_desc), return_value, field_desc);                    
+                }
+            }
+            
+
+            template<typename Action, typename ReturnType>
+                ReturnType traverse_const_message(const boost::any& wire_value)
+            {
+                try
+                {
+                    ReturnType return_value = ReturnType();
+       
+                    const google::protobuf::Message* msg = boost::any_cast<const google::protobuf::Message*>(wire_value);
+                    const google::protobuf::Descriptor* desc = msg->GetDescriptor();
+                    const google::protobuf::Reflection* refl = msg->GetReflection();
+                    for(int i = 0, n = desc->field_count(); i < n; ++i)
+                    {       
+                        const google::protobuf::FieldDescriptor* field_desc = desc->field(i);
+
+                        if(!check_field(field_desc))
+                            continue;
+           
+                        boost::shared_ptr<FieldCodecBase> codec = find(field_desc);
+                        boost::shared_ptr<FromProtoCppTypeBase> helper =
+                            TypeHelper::find(field_desc);
+            
+            
+                        if(field_desc->is_repeated())
+                        {
+                            std::vector<boost::any> field_values;
+                            for(int j = 0, m = refl->FieldSize(*msg, field_desc); j < m; ++j)
+                                field_values.push_back(helper->get_repeated_value(field_desc, *msg, j));
+                   
+                            Action::repeated(codec, &return_value, field_values, field_desc);
+                        }
+                        else
+                        {
+                            Action::single(codec, &return_value, helper->get_value(field_desc, *msg), field_desc);
+                        }
+                    }
+                    return return_value;
+                }
+                catch(boost::bad_any_cast& e)
+                {
+                    throw(Exception("Bad type given to traverse const, expecting const google::protobuf::Message*, got " + std::string(wire_value.type().name())));
+                }
+                
+            }
+        };
+
+    }
+}
+
+//encode, size, etc.
+
+
+
+
+#endif

=== modified file 'src/field_codec.cpp'
--- src/field_codec.cpp	2014-04-22 20:10:37 +0000
+++ src/field_codec.cpp	2014-08-27 16:27:22 +0000
@@ -29,6 +29,7 @@
     dccl::MessageStack::UNKNOWN;
 
 const google::protobuf::Message* dccl::FieldCodecBase::root_message_ = 0;
+const google::protobuf::Descriptor* dccl::FieldCodecBase::root_descriptor_ = 0;
 
 using dccl::dlog;
 using namespace dccl::logger;
@@ -66,6 +67,7 @@
     
     Bitset new_bits;
     any_encode(&new_bits, wire_value);
+    disp_size(field, new_bits, msg_handler.field_.size());
     bits->append(new_bits);
 }
 
@@ -80,6 +82,7 @@
     
     Bitset new_bits;
     any_encode_repeated(&new_bits, wire_values);
+    disp_size(field, new_bits, msg_handler.field_.size(), wire_values.size());
     bits->append(new_bits);
 }
 
@@ -190,7 +193,8 @@
 
     std::vector<boost::any> wire_values = *field_values;
     any_decode_repeated(&these_bits, &wire_values);
-    
+
+    field_values->clear();
     field_post_decode_repeated(wire_values, field_values);
 }
 
@@ -199,7 +203,7 @@
                                          const google::protobuf::Descriptor* desc,
                                          MessageStack::MessagePart part)
 {
-    BaseRAII scoped_globals(part);
+    BaseRAII scoped_globals(part, desc);
     *bit_size = 0;
 
     MessageStack msg_handler;
@@ -228,7 +232,7 @@
                                          const google::protobuf::Descriptor* desc,
                                          MessageStack::MessagePart part)
 {
-    BaseRAII scoped_globals(part);
+    BaseRAII scoped_globals(part, desc);
 
     *bit_size = 0;
 
@@ -257,7 +261,7 @@
 void dccl::FieldCodecBase::base_validate(const google::protobuf::Descriptor* desc,
                                          MessageStack::MessagePart part)
 {
-    BaseRAII scoped_globals(part);
+    BaseRAII scoped_globals(part, desc);
 
     MessageStack msg_handler;
     if(desc)
@@ -283,7 +287,7 @@
             
 void dccl::FieldCodecBase::base_info(std::ostream* os, const google::protobuf::Descriptor* desc, MessageStack::MessagePart part)
 {
-    BaseRAII scoped_globals(part);
+    BaseRAII scoped_globals(part, desc);
 
     MessageStack msg_handler;
     if(desc)
@@ -337,7 +341,11 @@
     }
 
     int width = this_field() ? full_width-name.size() : full_width-name.size()+spaces;
-    ss << indent << name << std::setfill('.') << std::setw(std::max(1, width)) << range.str();
+    ss << indent << name <<
+        std::setfill('.') << std::setw(std::max(1, width)) << range.str()
+       << " {" << (this_field() ? FieldCodecManager::find(this_field(), has_codec_group(), codec_group())->name() : FieldCodecManager::find(root_descriptor_)->name()) << "}";
+
+    
     
 //    std::string s = ss.str();
 //    boost::replace_all(s, "\n", "\n" + indent);    
@@ -353,6 +361,14 @@
 
 }
 
+std::string dccl::FieldCodecBase::codec_group(const google::protobuf::Descriptor* desc)
+{
+    if(desc->options().GetExtension(dccl::msg).has_codec_group())
+        return desc->options().GetExtension(dccl::msg).codec_group();
+    else
+        return Codec::default_codec_name(desc->options().GetExtension(dccl::msg).codec_version());
+}
+
 
 //
 // FieldCodecBase protected
@@ -366,7 +382,18 @@
 void dccl::FieldCodecBase::any_encode_repeated(dccl::Bitset* bits, const std::vector<boost::any>& wire_values)
 {
     // out_bits = [field_values[2]][field_values[1]][field_values[0]]
-    for(unsigned i = 0, n = dccl_field_options().max_repeat(); i < n; ++i)
+
+    unsigned wire_vector_size = dccl_field_options().max_repeat();
+
+    // for DCCL3 and beyond, add a prefix numeric field giving the vector size (rather than always going to max_repeat
+    if(codec_version() > 2)
+    {
+        wire_vector_size = std::min((int)dccl_field_options().max_repeat(), (int)wire_values.size());    
+        Bitset size_bits(repeated_vector_field_size(dccl_field_options().max_repeat()), wire_values.size());
+        bits->append(size_bits);
+    }    
+
+    for(unsigned i = 0, n = wire_vector_size; i < n; ++i)
     {
         Bitset new_bits;
         if(i < wire_values.size())
@@ -379,27 +406,41 @@
 }
 
 
+
 void dccl::FieldCodecBase::any_decode_repeated(Bitset* repeated_bits, std::vector<boost::any>* wire_values)
 {
-    for(unsigned i = 0, n = dccl_field_options().max_repeat(); i < n; ++i)
+
+    unsigned wire_vector_size = dccl_field_options().max_repeat();    
+    if(codec_version() > 2)
+    {
+        Bitset size_bits(repeated_bits);        
+        size_bits.get_more_bits(repeated_vector_field_size(dccl_field_options().max_repeat()));
+
+        wire_vector_size = size_bits.to_ulong();
+    }
+
+    wire_values->resize(wire_vector_size);
+    
+    for(unsigned i = 0, n = wire_vector_size; i < n; ++i)
     {
         Bitset these_bits(repeated_bits);        
-        these_bits.get_more_bits(min_size());
-        
-        boost::any value;
-        
-        if(wire_values->size() > i)
-            value = (*wire_values)[i];
-        
-        any_decode(&these_bits, &value);
-        wire_values->push_back(value);
+        these_bits.get_more_bits(min_size());        
+        any_decode(&these_bits, &(*wire_values)[i]);
     }
 }
 
 unsigned dccl::FieldCodecBase::any_size_repeated(const std::vector<boost::any>& wire_values)
 {
     unsigned out = 0;
-    for(unsigned i = 0, n = dccl_field_options().max_repeat(); i < n; ++i)
+    unsigned wire_vector_size = dccl_field_options().max_repeat();
+
+    if(codec_version() > 2)
+    {
+        wire_vector_size = std::min((int)dccl_field_options().max_repeat(), (int)wire_values.size());    
+        out += repeated_vector_field_size(dccl_field_options().max_repeat());
+    }    
+
+    for(unsigned i = 0, n = wire_vector_size; i < n; ++i)
     {
         if(i < wire_values.size())
             out += any_size(wire_values[i]);
@@ -413,6 +454,8 @@
 {    
     if(!dccl_field_options().has_max_repeat())
         throw(Exception("Missing (dccl.field).max_repeat option on `repeated` field: " + this_field()->DebugString()));
+    else if(codec_version() > 2)
+        return repeated_vector_field_size(dccl_field_options().max_repeat()) + max_size() * dccl_field_options().max_repeat();
     else
         return max_size() * dccl_field_options().max_repeat();
 }
@@ -421,6 +464,8 @@
 {    
     if(!dccl_field_options().has_max_repeat())
         throw(Exception("Missing (dccl.field).max_repeat option on `repeated` field " + this_field()->DebugString()));
+    else if(codec_version() > 2)
+        return repeated_vector_field_size(dccl_field_options().max_repeat());    
     else
         return min_size() * dccl_field_options().max_repeat();
 }
@@ -453,3 +498,22 @@
 // FieldCodecBase private
 //
 
+void dccl::FieldCodecBase::disp_size(const google::protobuf::FieldDescriptor* field, const Bitset& new_bits, int depth, int vector_size /* = -1 */)
+{
+    if(!root_descriptor_)
+        return;
+
+    if(dlog.is(INFO, SIZE))
+    {   
+        std::string name = ((field) ? field->name() : root_descriptor_->full_name());
+        if(vector_size >= 0)
+            name +=  "[" + boost::lexical_cast<std::string>(vector_size) +  "]";
+
+        
+        dlog << std::string(depth, '|') << name << std::setfill('.') << std::setw(40-name.size()-depth) << new_bits.size() << std::endl;
+        
+        if(!field)
+            dlog << std::endl;
+        
+    }
+}

=== modified file 'src/field_codec.h'
--- src/field_codec.h	2014-04-22 20:10:37 +0000
+++ src/field_codec.h	2014-08-27 16:27:22 +0000
@@ -28,6 +28,7 @@
 #include <string>
 
 #include <boost/any.hpp>
+#include <boost/lexical_cast.hpp>
 
 #include <google/protobuf/message.h>
 #include <google/protobuf/descriptor.pb.h>
@@ -38,6 +39,7 @@
 #include "dccl/protobuf/option_extensions.pb.h"
 #include "type_helper.h"
 #include "field_codec_message_stack.h"
+#include "dccl/binary.h"
 
 namespace dccl
 {
@@ -94,7 +96,25 @@
         // currently encoded or (partially) decoded root message
         static const google::protobuf::Message* root_message()
         { return root_message_; }
-            
+
+        static bool has_codec_group()
+        {
+            if(root_descriptor_)
+            {
+                return root_descriptor_->options().GetExtension(dccl::msg).has_codec_group() ||
+                    root_descriptor_->options().GetExtension(dccl::msg).has_codec_version();
+            }
+            else
+                return false;
+        }
+
+        static std::string codec_group(const google::protobuf::Descriptor* desc);
+
+        static std::string codec_group()
+        { return codec_group(root_descriptor_); }
+
+        static int codec_version()
+        { return root_descriptor_->options().GetExtension(dccl::msg).codec_version(); }
             
         /// \brief the part of the message currently being encoded (head or body).
         static MessageStack::MessagePart part() { return part_; }
@@ -379,7 +399,6 @@
         ///
         /// \return Minimum size of this field (in bits).
         virtual unsigned min_size() = 0;
-            
 
         virtual void any_encode_repeated(Bitset* bits, const std::vector<boost::any>& wire_values);
         virtual void any_decode_repeated(Bitset* repeated_bits, std::vector<boost::any>* field_values);
@@ -404,29 +423,52 @@
         void set_wire_type(google::protobuf::FieldDescriptor::CppType type)
         { wire_type_ = type; }
 
-        bool variable_size() { return max_size() != min_size(); }            
-            
+        bool variable_size()
+        {
+            if(this_field() && this_field()->is_repeated())
+                return max_size_repeated() != min_size_repeated();
+            else
+                return max_size() != min_size();
+        }            
+
+        int repeated_vector_field_size(int max_repeat)
+        { return dccl::ceil_log2(max_repeat+1); }
+
+        void disp_size(const google::protobuf::FieldDescriptor* field, const Bitset& new_bits, int depth, int vector_size = -1);
+        
+        
       private:
         // sets global statics relating the current message begin processed
         // and unsets them on destruction
         struct BaseRAII
         {
             BaseRAII(MessageStack::MessagePart part,
-                     const google::protobuf::Message* root_message = 0)
+                     const google::protobuf::Descriptor* root_descriptor)
+                {
+                    FieldCodecBase::part_ = part;
+                    FieldCodecBase::root_message_ = 0;
+                    FieldCodecBase::root_descriptor_ = root_descriptor;
+                }
+
+            BaseRAII(MessageStack::MessagePart part,            
+                     const google::protobuf::Message* root_message)
                 {
                     FieldCodecBase::part_ = part;
                     FieldCodecBase::root_message_ = root_message;
+                    FieldCodecBase::root_descriptor_ = root_message->GetDescriptor();                    
                 }
             ~BaseRAII()
                 {
                     FieldCodecBase::part_ = dccl::MessageStack::UNKNOWN;
                     FieldCodecBase::root_message_ = 0;
+                    FieldCodecBase::root_descriptor_ = 0;
                 }
         };
         
         
         static MessageStack::MessagePart part_;
         static const google::protobuf::Message* root_message_;
+        static const google::protobuf::Descriptor* root_descriptor_;
         
         std::string name_;
         google::protobuf::FieldDescriptor::Type field_type_;

=== added file 'src/field_codec_id.cpp'
--- src/field_codec_id.cpp	1970-01-01 00:00:00 +0000
+++ src/field_codec_id.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,100 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "field_codec_id.h"
+
+//
+// DefaultIdentifierCodec
+//
+
+dccl::Bitset dccl::DefaultIdentifierCodec::encode()
+{
+    return encode(0);
+}
+
+dccl::Bitset dccl::DefaultIdentifierCodec::encode(const uint32& id)
+{
+    if(id <= ONE_BYTE_MAX_ID)
+    {
+        return(dccl::Bitset(this_size(id), id) << 1);
+    }
+    else
+    {
+        dccl::Bitset return_bits(this_size(id), id);
+        return_bits <<= 1;
+        // set LSB to indicate long header form
+        return_bits.set(0, true);
+
+        
+        return return_bits;
+    }
+}
+
+dccl::uint32 dccl::DefaultIdentifierCodec::decode(Bitset* bits)
+{
+    if(bits->test(0))
+    {
+        // long header
+        // grabs more bits to add to the MSB of `bits`
+        bits->get_more_bits((LONG_FORM_ID_BYTES - SHORT_FORM_ID_BYTES)*BITS_IN_BYTE);
+        // discard identifier
+        *(bits) >>= 1;
+        return bits->to_ulong();
+    }
+    else
+    {
+        // short header
+        *(bits) >>= 1;
+        return bits->to_ulong();
+    }
+}
+
+unsigned dccl::DefaultIdentifierCodec::size()
+{
+    return this_size(0);
+}
+
+unsigned dccl::DefaultIdentifierCodec::size(const uint32& id)
+{
+    return this_size(id);
+}
+
+unsigned dccl::DefaultIdentifierCodec::this_size(const uint32& id)
+{
+    if(id > TWO_BYTE_MAX_ID)
+        throw(Exception("dccl.id provided (" + boost::lexical_cast<std::string>(id) + ") exceeds maximum: " + boost::lexical_cast<std::string>(int(TWO_BYTE_MAX_ID))));
+    
+    return (id <= ONE_BYTE_MAX_ID) ?
+        SHORT_FORM_ID_BYTES*BITS_IN_BYTE :
+        LONG_FORM_ID_BYTES*BITS_IN_BYTE;
+}
+
+
+unsigned dccl::DefaultIdentifierCodec::max_size()
+{
+    return LONG_FORM_ID_BYTES * BITS_IN_BYTE;
+}
+
+unsigned dccl::DefaultIdentifierCodec::min_size()
+{
+    return SHORT_FORM_ID_BYTES * BITS_IN_BYTE;
+}

=== added file 'src/field_codec_id.h'
--- src/field_codec_id.h	1970-01-01 00:00:00 +0000
+++ src/field_codec_id.h	2014-08-27 16:27:22 +0000
@@ -0,0 +1,50 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "field_codec_fixed.h"
+
+namespace dccl
+{
+    /// \brief Provides the default 1 byte or 2 byte DCCL ID codec
+    class DefaultIdentifierCodec : public TypedFieldCodec<uint32>
+    {
+      protected:
+        virtual Bitset encode();
+        virtual Bitset encode(const uint32& wire_value);
+        virtual uint32 decode(Bitset* bits);
+        virtual unsigned size();
+        virtual unsigned size(const uint32& wire_value);
+        virtual unsigned max_size();
+        virtual unsigned min_size();
+        virtual void validate() { }
+
+      private:
+        unsigned this_size(const uint32& wire_value);
+        // maximum id we can fit in short or long header (MSB reserved to indicate
+        // short or long header)
+        enum { ONE_BYTE_MAX_ID = (1 << 7) - 1,
+               TWO_BYTE_MAX_ID = (1 << 15) - 1};
+            
+        enum { SHORT_FORM_ID_BYTES = 1,
+               LONG_FORM_ID_BYTES = 2 };
+    };
+}

=== modified file 'src/field_codec_manager.h'
--- src/field_codec_manager.h	2014-04-22 20:10:37 +0000
+++ src/field_codec_manager.h	2014-08-27 16:27:22 +0000
@@ -81,12 +81,49 @@
         template<class Codec, google::protobuf::FieldDescriptor::Type type>
             static void add(const std::string& name);
 
+        /// \brief Remove a new field codec (used for codecs operating on statically generated Protobuf messages, that is, children of google::protobuf::Message but not google::protobuf::Message itself).
+        ///
+        /// \tparam Codec A child of FieldCodecBase
+        /// \param name Name to use for this codec. Corresponds to (dccl.field).codec="name" in .proto file.
+        /// \return nothing (void). Return templates are used for template metaprogramming selection of the proper remove() overload.
+        template<class Codec>
+            typename boost::enable_if<
+            boost::mpl::and_<boost::is_base_of<google::protobuf::Message, typename Codec::wire_type>,
+            boost::mpl::not_<boost::is_same<google::protobuf::Message, typename Codec::wire_type> >
+            >,
+            void>::type 
+            static remove(const std::string& name, dummy_fcm<0> dummy_fcm = 0);
+                
+        /// \brief Remove a new field codec (used for codecs operating on all types except statically generated Protobuf messages).
+        ///
+        /// \tparam Codec A child of FieldCodecBase
+        /// \param name Name to use for this codec. Corresponds to (dccl.field).codec="name" in .proto file.
+        /// \return nothing (void). Return templates are used for template metaprogramming selection of the proper remove() overload.
+        template<class Codec>
+            typename boost::disable_if<
+            boost::mpl::and_<boost::is_base_of<google::protobuf::Message, typename Codec::wire_type>,
+            boost::mpl::not_<boost::is_same<google::protobuf::Message,typename Codec::wire_type> >
+            >,
+            void>::type
+            static remove(const std::string& name, dummy_fcm<1> dummy_fcm = 0);
+                
+        /// \brief Remove a new field codec only valid for a specific google::protobuf::FieldDescriptor::Type. This is useful if a given codec is designed to work with only a specific Protobuf type that shares an underlying C++ type (e.g. Protobuf types `bytes` and `string`)
+        ///
+        /// \tparam Codec A child of FieldCodecBase
+        /// \tparam type The google::protobuf::FieldDescriptor::Type enumeration that this codec works on.
+        /// \param name Name to use for this codec. Corresponds to (dccl.field).codec="name" in .proto file.
+        template<class Codec, google::protobuf::FieldDescriptor::Type type>
+            static void remove(const std::string& name);
+
+        
         /// \brief Find the codec for a given field. For embedded messages, prefers (dccl.field).codec (inside field) over (dccl.msg).codec (inside embedded message).
         static boost::shared_ptr<FieldCodecBase> find(
-            const google::protobuf::FieldDescriptor* field)
+            const google::protobuf::FieldDescriptor* field,
+            bool has_codec_group,
+            const std::string& codec_group)
         {
-            std::string name = __find_codec(field);
-                
+            std::string name = __find_codec(field, has_codec_group, codec_group);            
+            
             if(field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
                 return find(field->message_type(), name);
             else
@@ -101,9 +138,16 @@
             const google::protobuf::Descriptor* desc,
             std::string name = "")
         {
+            // this was called on the root message
             if(name.empty())
-                name = desc->options().GetExtension(dccl::msg).codec();
-
+            {
+                // explicitly declared codec takes precedence over group
+                if(desc->options().GetExtension(dccl::msg).has_codec())
+                    name = desc->options().GetExtension(dccl::msg).codec();
+                else
+                    name = FieldCodecBase::codec_group(desc);
+            }
+            
             return __find(google::protobuf::FieldDescriptor::TYPE_MESSAGE,
                           name, desc->full_name());
         }
@@ -115,6 +159,11 @@
             return __find(type, name);
         }
 
+        static void clear()
+        {
+            TypeHelper::reset();
+            codecs_.clear();
+        }
         
         
       private:
@@ -132,27 +181,41 @@
             
         static std::string __mangle_name(const std::string& codec_name,
                                          const std::string& type_name) 
-        { return type_name.empty() ? codec_name : codec_name + "@@" + type_name; }
+        { return type_name.empty() ? codec_name : codec_name + "[" + type_name + "]"; }
                 
 
         template<typename WireType, typename FieldType, class Codec> 
-            static void __add(const std::string& name); 
-
-        template<class Codec>
-            static void __add(const std::string& name,
-                              google::protobuf::FieldDescriptor::Type field_type,
-                              google::protobuf::FieldDescriptor::CppType wire_type);
-
-
-        static std::string __find_codec(const google::protobuf::FieldDescriptor* field)
+            static void add_all_types(const std::string& name); 
+
+        template<class Codec>
+            static void add_single_type(const std::string& name,
+                                        google::protobuf::FieldDescriptor::Type field_type,
+                                        google::protobuf::FieldDescriptor::CppType wire_type);
+        
+        template<typename WireType, typename FieldType, class Codec> 
+            static void remove_all_types(const std::string& name); 
+
+        template<class Codec>
+            static void remove_single_type(const std::string& name,
+                                        google::protobuf::FieldDescriptor::Type field_type,
+                                        google::protobuf::FieldDescriptor::CppType wire_type);
+
+        
+        static std::string __find_codec(const google::protobuf::FieldDescriptor* field,
+                                        bool has_codec_group, const std::string& codec_group)
         {
             dccl::DCCLFieldOptions dccl_field_options = field->options().GetExtension(dccl::field);
                 
             // prefer the codec listed as a field extension
             if(dccl_field_options.has_codec())
-                return dccl_field_options.codec();
-            else if(field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
+                return dccl_field_options.codec();                
+            // then, the codec embedded in the message option extension
+            else if(field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE && field->message_type()->options().GetExtension(dccl::msg).has_codec())
                 return field->message_type()->options().GetExtension(dccl::msg).codec();
+            // then the overarching codec group
+            else if(has_codec_group)
+                return codec_group;
+            // finally the default
             else
                 return dccl_field_options.codec();
         }
@@ -173,9 +236,9 @@
 dccl::FieldCodecManager::add(const std::string& name, dummy_fcm<0> dummy_fcm)
 {
     TypeHelper::add<typename Codec::wire_type>();
-    __add<Codec>(__mangle_name(name, Codec::wire_type::descriptor()->full_name()),
-                 google::protobuf::FieldDescriptor::TYPE_MESSAGE,
-                 google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE);
+    add_single_type<Codec>(__mangle_name(name, Codec::wire_type::descriptor()->full_name()),
+                           google::protobuf::FieldDescriptor::TYPE_MESSAGE,
+                           google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE);
 }
 
 template<class Codec>
@@ -187,18 +250,18 @@
     void>::type
     dccl::FieldCodecManager::add(const std::string& name, dummy_fcm<1> dummy_fcm)
 {
-    __add<typename Codec::wire_type, typename Codec::field_type, Codec>(name);
+    add_all_types<typename Codec::wire_type, typename Codec::field_type, Codec>(name);
 }
 
 template<class Codec, google::protobuf::FieldDescriptor::Type type> 
     void dccl::FieldCodecManager::add(const std::string& name) 
 { 
-    __add<Codec>(name, type, google::protobuf::FieldDescriptor::TypeToCppType(type));
+    add_single_type<Codec>(name, type, google::protobuf::FieldDescriptor::TypeToCppType(type));
 }
 
 
 template<typename WireType, typename FieldType, class Codec>
-    void dccl::FieldCodecManager::__add(const std::string& name)
+    void dccl::FieldCodecManager::add_all_types(const std::string& name)
 {
     using google::protobuf::FieldDescriptor;
     const FieldDescriptor::CppType cpp_field_type = ToProtoCppType<FieldType>::as_enum();
@@ -209,17 +272,17 @@
         FieldDescriptor::Type field_type = static_cast<FieldDescriptor::Type>(i);
         if(FieldDescriptor::TypeToCppType(field_type) == cpp_field_type)
         {            
-            __add<Codec>(name, field_type, cpp_wire_type);
+            add_single_type<Codec>(name, field_type, cpp_wire_type);
         }
     }
 }
 
 template<class Codec>
-void dccl::FieldCodecManager::__add(const std::string& name,
-                                        google::protobuf::FieldDescriptor::Type field_type,
-                                        google::protobuf::FieldDescriptor::CppType wire_type)
+void dccl::FieldCodecManager::add_single_type(const std::string& name,
+                                              google::protobuf::FieldDescriptor::Type field_type,
+                                              google::protobuf::FieldDescriptor::CppType wire_type)
 {
-    using google::protobuf::FieldDescriptor;    
+    using google::protobuf::FieldDescriptor;
     if(!codecs_[field_type].count(name))
     {
         boost::shared_ptr<FieldCodecBase> new_field_codec(new Codec());
@@ -246,4 +309,82 @@
 
 
 
+template<class Codec>
+typename boost::enable_if<
+boost::mpl::and_<
+boost::is_base_of<google::protobuf::Message, typename Codec::wire_type>,
+boost::mpl::not_<boost::is_same<google::protobuf::Message, typename Codec::wire_type> >
+>,
+void>::type 
+dccl::FieldCodecManager::remove(const std::string& name, dummy_fcm<0> dummy_fcm)
+{
+    TypeHelper::remove<typename Codec::wire_type>();
+    remove_single_type<Codec>(__mangle_name(name, Codec::wire_type::descriptor()->full_name()),
+                              google::protobuf::FieldDescriptor::TYPE_MESSAGE,
+                              google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE);
+}
+
+template<class Codec>
+typename boost::disable_if<
+boost::mpl::and_<
+boost::is_base_of<google::protobuf::Message, typename Codec::wire_type>,
+    boost::mpl::not_<boost::is_same<google::protobuf::Message, typename Codec::wire_type> >
+    >,
+    void>::type
+    dccl::FieldCodecManager::remove(const std::string& name, dummy_fcm<1> dummy_fcm)
+{
+    remove_all_types<typename Codec::wire_type, typename Codec::field_type, Codec>(name);
+}
+
+template<class Codec, google::protobuf::FieldDescriptor::Type type> 
+    void dccl::FieldCodecManager::remove(const std::string& name) 
+{ 
+    remove_single_type<Codec>(name, type, google::protobuf::FieldDescriptor::TypeToCppType(type));
+}
+
+
+template<typename WireType, typename FieldType, class Codec>
+    void dccl::FieldCodecManager::remove_all_types(const std::string& name)
+{
+    using google::protobuf::FieldDescriptor;
+    const FieldDescriptor::CppType cpp_field_type = ToProtoCppType<FieldType>::as_enum();
+    const FieldDescriptor::CppType cpp_wire_type = ToProtoCppType<WireType>::as_enum();
+
+    for(int i = 1, n = FieldDescriptor::MAX_TYPE; i <= n; ++i)
+    {
+        FieldDescriptor::Type field_type = static_cast<FieldDescriptor::Type>(i);
+        if(FieldDescriptor::TypeToCppType(field_type) == cpp_field_type)
+        {            
+            remove_single_type<Codec>(name, field_type, cpp_wire_type);
+        }
+    }
+}
+
+template<class Codec>
+void dccl::FieldCodecManager::remove_single_type(const std::string& name,
+                                              google::protobuf::FieldDescriptor::Type field_type,
+                                              google::protobuf::FieldDescriptor::CppType wire_type)
+{
+    using google::protobuf::FieldDescriptor;
+    if(codecs_[field_type].count(name))
+    {       
+        dccl::dlog.is(dccl::logger::DEBUG1) && dccl::dlog << "Removing codec " << *codecs_[field_type][name]  << std::endl;
+        codecs_[field_type].erase(name);
+    }            
+    else
+    {
+        boost::shared_ptr<FieldCodecBase> new_field_codec(new Codec());
+        new_field_codec->set_name(name);
+        new_field_codec->set_field_type(field_type);
+        new_field_codec->set_wire_type(wire_type);
+        
+        dccl::dlog.is(dccl::logger::DEBUG1) && dccl::dlog << "Trying to remove: " << *new_field_codec
+                                                            << ", but no such codec exists"
+                                                            << std::endl;
+    }
+}
+
+
+
+
 #endif

=== modified file 'src/field_codec_message_stack.cpp'
--- src/field_codec_message_stack.cpp	2014-04-22 20:10:37 +0000
+++ src/field_codec_message_stack.cpp	2014-08-27 16:27:22 +0000
@@ -26,7 +26,7 @@
 
 std::vector<const google::protobuf::FieldDescriptor*> dccl::MessageStack::field_;
 std::vector<const google::protobuf::Descriptor*> dccl::MessageStack::desc_;
-dccl::MessageStack::MessagePart dccl::MessageStack::current_part_ = dccl::MessageStack::UNKNOWN;
+std::vector<dccl::MessageStack::MessagePart> dccl::MessageStack::parts_;
 
 //
 // MessageStack
@@ -45,6 +45,12 @@
     ++fields_pushed_;
 }
 
+void dccl::MessageStack::push(MessagePart part)
+{
+    parts_.push_back(part);
+    ++parts_pushed_;
+}
+
 
 void dccl::MessageStack::__pop_desc()
 {
@@ -58,17 +64,34 @@
         field_.pop_back();
 }
 
+void dccl::MessageStack::__pop_parts()
+{
+    if(!parts_.empty())
+        parts_.pop_back();
+}
+
+
 dccl::MessageStack::MessageStack(const google::protobuf::FieldDescriptor* field)
     : descriptors_pushed_(0),
-      fields_pushed_(0)
+      fields_pushed_(0),
+      parts_pushed_(0)
 {
     if(field)
     {
         if(field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE)
         {
-            // if explicitly set, set part (HEAD or BODY) of message for all children of this message
+            MessagePart part = UNKNOWN;
             if(field->options().GetExtension(dccl::field).has_in_head())
-                current_part_ = field->options().GetExtension(dccl::field).in_head() ? HEAD : BODY;
+            {
+                // if explicitly set, set part (HEAD or BODY) of message for all children of this message
+                part = field->options().GetExtension(dccl::field).in_head() ? HEAD : BODY;
+            }
+            else
+            {
+                // use the parent's current part
+                part = current_part();
+            }
+            push(part);
             
             push(field->message_type());
         }
@@ -77,3 +100,14 @@
     
 }
 
+dccl::MessageStack::~MessageStack()
+{
+    for(int i = 0; i < fields_pushed_; ++i)
+        __pop_field();
+
+    for(int i = 0; i < descriptors_pushed_; ++i)
+        __pop_desc();
+
+    for(int i = 0; i < parts_pushed_; ++i)
+        __pop_parts();    
+}

=== modified file 'src/field_codec_message_stack.h'
--- src/field_codec_message_stack.h	2014-04-22 20:10:37 +0000
+++ src/field_codec_message_stack.h	2014-08-27 16:27:22 +0000
@@ -34,19 +34,7 @@
       public:
         MessageStack(const google::protobuf::FieldDescriptor* field = 0);
                 
-        ~MessageStack()
-        {
-            for(int i = 0; i < descriptors_pushed_; ++i)
-                __pop_desc();
-                    
-            for(int i = 0; i < fields_pushed_; ++i)
-                __pop_field();
-
-            if(desc_.empty())
-            {
-                current_part_ = UNKNOWN;
-            }    
-        }
+        ~MessageStack();
 
         enum MessagePart { HEAD, BODY, UNKNOWN };
             
@@ -57,19 +45,22 @@
 
         void push(const google::protobuf::Descriptor* desc);
         void push(const google::protobuf::FieldDescriptor* field);
+        void push(MessagePart part);
 
-        static MessagePart current_part() { return current_part_; }
-            
+        static MessagePart current_part() { return parts_.empty() ? UNKNOWN : parts_.back(); }
+        
         friend class FieldCodecBase;
       private:
         void __pop_desc();
         void __pop_field();
+        void __pop_parts();
                 
         static std::vector<const google::protobuf::Descriptor*> desc_;
         static std::vector<const google::protobuf::FieldDescriptor*> field_;
+        static std::vector<MessagePart> parts_;
         int descriptors_pushed_;
         int fields_pushed_;
-        static MessagePart current_part_;
+        int parts_pushed_;
     };
 }
 

=== modified file 'src/field_codec_typed.h'
--- src/field_codec_typed.h	2014-04-22 20:10:37 +0000
+++ src/field_codec_typed.h	2014-08-27 16:27:22 +0000
@@ -24,6 +24,9 @@
 #ifndef DCCLFIELDCODECTYPED20120312H
 #define DCCLFIELDCODECTYPED20120312H
 
+
+#include <boost/type_traits.hpp>
+
 #include "field_codec.h"
 
 namespace dccl
@@ -72,7 +75,7 @@
         class TypedFieldCodec : public FieldCodecSelector<WireType, FieldType>
     {
       public:
-      typedef WireType wire_type;
+typedef WireType wire_type;
       typedef FieldType field_type;
 
       public:
@@ -256,8 +259,14 @@
       ///
       /// \param bits Bits to use for decoding.
       /// \return the decoded value.
-      virtual WireType decode(Bitset* bits)
-      { return decode_repeated(bits).at(0); }          
+      virtual WireType decode(dccl::Bitset* bits)
+      {
+          std::vector<WireType> return_vec = decode_repeated(bits);
+          if(return_vec.empty())
+              throw dccl::NullValueException();
+          else
+              return return_vec.at(0);
+      }
 
       /// \brief Calculate the size (in bits) of an empty field.
       ///

=== modified file 'src/logger.cpp'
--- src/logger.cpp	2014-04-22 20:10:37 +0000
+++ src/logger.cpp	2014-08-27 16:27:22 +0000
@@ -55,6 +55,7 @@
         case logger::GENERAL: break;
         case logger::ENCODE: grp_str = "{encode}: "; break;
         case logger::DECODE: grp_str = "{decode}: "; break;
+        case logger::SIZE: grp_str = "{size}: "; break;
     }
     
     std::time_t now = std::time(0);
@@ -64,11 +65,12 @@
     {
         *os << "[ " << (t->tm_year+1900) << "-"
             << std::setw(2) << std::setfill('0') << (t->tm_mon+1) << "-"
-            << std::setw(2) << std::setfill('0') << t->tm_mday
+            << std::setw(2) << t->tm_mday
             << " "
-            << std::setw(2) << std::setfill('0') << t->tm_hour << ":"
-            << std::setw(2) << std::setfill('0') << t->tm_min << ":"
-            << std::setw(2) << std::setfill('0') << t->tm_sec << " ]: ";
+            << std::setw(2) << t->tm_hour << ":"
+            << std::setw(2) << t->tm_min << ":"
+            << std::setw(2) << t->tm_sec << " ]: "
+            << std::setfill(' ');
     }
     
     *os << grp_str << msg << std::endl;

=== modified file 'src/logger.h'
--- src/logger.h	2014-04-22 20:10:37 +0000
+++ src/logger.h	2014-08-27 16:27:22 +0000
@@ -47,10 +47,11 @@
             DEBUG3_PLUS = DEBUG3 | (DEBUG3 - 1)
         };
         enum Group 
-        { GENERAL, ENCODE, DECODE };
+        { GENERAL, ENCODE, DECODE, SIZE };
   
     }
 
+    
 
     void to_ostream(const std::string& msg, dccl::logger::Verbosity vrb,
                     dccl::logger::Group grp, std::ostream* os, bool add_timestamp);

=== modified file 'src/protobuf/option_extensions.proto'
--- src/protobuf/option_extensions.proto	2013-08-20 16:17:28 +0000
+++ src/protobuf/option_extensions.proto	2014-08-27 16:27:22 +0000
@@ -25,7 +25,7 @@
 message DCCLFieldOptions
 {
   // what encoder / decoder should we use?
-  optional string codec = 1 [default = "dccl.default"];
+  optional string codec = 1 [default = "dccl.default2"];
   // leave this field out of DCCL transmissions (has_field() will be false on receipt)
   optional bool omit = 2 [default = false];
   // set true for fields in the header (will *not* be encrypte)d
@@ -60,9 +60,12 @@
 
 message DCCLMessageOptions
 {
-  required int32 id = 1;
-  required uint32 max_bytes = 2;
-
-  optional string codec = 3 [default = "dccl.default"];
+  optional int32 id = 1;
+  optional uint32 max_bytes = 2;
+
+  optional string codec = 3 [default = "dccl.default2"];
+
+  optional string codec_group = 4 [default = "dccl.default2"];
+  optional int32 codec_version = 5 [default = 2];
 }
 

=== modified file 'src/test/CMakeLists.txt'
--- src/test/CMakeLists.txt	2014-03-26 16:25:12 +0000
+++ src/test/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -10,6 +10,8 @@
 add_subdirectory(dccl_static_methods)
 add_subdirectory(dccl_custom_id)
 add_subdirectory(dccl_numeric_bounds)
+add_subdirectory(dccl_codec_group)
+add_subdirectory(dccl_message_fix)
 
 if(build_ccl)
   add_subdirectory(dccl_ccl)
@@ -19,6 +21,9 @@
   add_subdirectory(dccl_arithmetic)
 endif()
 
+add_subdirectory(dccl_v2_all_fields)
+add_subdirectory(dccl_v2_header)
+
 add_subdirectory(bitset1)
 
 add_subdirectory(logger1)

=== modified file 'src/test/dccl_all_fields/test.cpp'
--- src/test/dccl_all_fields/test.cpp	2014-04-22 20:13:39 +0000
+++ src/test/dccl_all_fields/test.cpp	2014-08-27 16:27:22 +0000
@@ -136,7 +136,9 @@
     decode_check(bytes);
 
     // make sure DCCL defaults stay wire compatible
-    decode_check(dccl::hex_decode("047f277b9628060000b95660c0b0188000d8c0132858800008000dc2c4c6626466024488cca8ee324bd05c3f23af0000ad9112a09509788013e0820b18e0005ed0204c6c2c4666062042644675975982c65235f10a00ad718a5801000000905f27121600000000a0170050640300309201001a0b00007d320a0000a61a0070b20100a81b00d09c6f0000a0401026361643102636160300f0dfbd5b2280ea2e330f3da59a2100aabfa55a000000000000000000000000"));
+
+    // v3
+    decode_check(dccl::hex_decode("047f277b16b95660c0b0188000d8c0132858800008002d4c6c2c4666264084c88cea2eb304cdeb67cc2b00b4464a805626e0014e800b2e60800378410b131b8b91990188109951dd6596a0b154cd7805506b9c2256caaf13094ba0978a6c248a692493c682fa6454a69a4e36a16e6ace37a918263616c330b1b118fd77ef9608a0bacbac574fa9cd1050fd6daa0500"));    
 
     // run a bunch of tests with random strings
     std::string random = bytes;

=== modified file 'src/test/dccl_all_fields/test.proto'
--- src/test/dccl_all_fields/test.proto	2012-10-19 16:41:36 +0000
+++ src/test/dccl_all_fields/test.proto	2014-08-27 16:27:22 +0000
@@ -29,6 +29,7 @@
 {
   option (dccl.msg).id = 2;
   option (dccl.msg).max_bytes = 512;
+  option (dccl.msg).codec_version = 3;
 
   // test default enc/dec
   optional double double_default_optional = 1 [(dccl.field).min=-100,
@@ -123,8 +124,7 @@
                                              (dccl.field).max_repeat=4];
   repeated uint32 uint32_default_repeat = 105 [(dccl.field).min=0,
                                                (dccl.field).max=100,
-                                               (dccl.field).max_repeat=4,
-                                               (dccl.field).in_head=true];
+                                               (dccl.field).max_repeat=4];
   repeated uint64 uint64_default_repeat = 106 [(dccl.field).min=0,
                                                (dccl.field).max=100,
                                                (dccl.field).max_repeat=4];

=== modified file 'src/test/dccl_arithmetic/test.proto'
--- src/test/dccl_arithmetic/test.proto	2012-10-23 00:46:12 +0000
+++ src/test/dccl_arithmetic/test.proto	2014-08-27 16:27:22 +0000
@@ -25,7 +25,8 @@
 {
   option (dccl.msg).id = 1;
   option (dccl.msg).max_bytes = 512;
-  
+  option (dccl.msg).codec_version = 3;
+    
   repeated double value = 101 [(dccl.field).codec = "_arithmetic",
                                (dccl.field).(arithmetic).model = "model",
                                (dccl.field).(arithmetic).debug_assert = true,
@@ -35,6 +36,7 @@
 {
   option (dccl.msg).id = 2;
   option (dccl.msg).max_bytes = 512;
+  option (dccl.msg).codec_version = 3;
   
   repeated Enum1 value = 114 [(dccl.field).codec = "_arithmetic",
                               (dccl.field).(arithmetic).model = "model",
@@ -47,6 +49,7 @@
 {
   option (dccl.msg).id = 3;
   option (dccl.msg).max_bytes = 512;
+  option (dccl.msg).codec_version = 3;
   
   required Enum1 value = 114 [(dccl.field).codec = "_arithmetic",
                               (dccl.field).(arithmetic).model = "model",
@@ -58,6 +61,7 @@
 {
   option (dccl.msg).id = 4;
   option (dccl.msg).max_bytes = 512;
+  option (dccl.msg).codec_version = 3;
   
   repeated Enum2 value = 114 [(dccl.field).codec = "_arithmetic",
                               (dccl.field).(arithmetic).model = "model",
@@ -70,6 +74,7 @@
 {
   option (dccl.msg).id = 5;
   option (dccl.msg).max_bytes = 10000;
+  option (dccl.msg).codec_version = 3;
   
   repeated int32 value = 101 [(dccl.field).codec = "_arithmetic",
                               (dccl.field).(arithmetic).model = "model",
@@ -82,6 +87,7 @@
 {
   option (dccl.msg).id = 6;
   option (dccl.msg).max_bytes = 10000;
+  option (dccl.msg).codec_version = 3;
   
   repeated int32 value = 101 [(dccl.field).codec = "_arithmetic",
                               (dccl.field).(arithmetic).model = "model",

=== modified file 'src/test/dccl_ccl/test.cpp'
--- src/test/dccl_ccl/test.cpp	2014-04-22 20:13:39 +0000
+++ src/test/dccl_ccl/test.cpp	2014-08-27 16:27:22 +0000
@@ -48,11 +48,9 @@
 {
     dccl::dlog.connect(dccl::logger::ALL, &std::cerr);    
 
-    {            
-	dccl::FieldCodecManager::add<dccl::LegacyCCLIdentifierCodec>("ccl_id_codec");
-        dccl::Codec codec("ccl_id_codec");
-
+    {
         void* dl_handle = dlopen("libdccl_ccl_compat" SHARED_LIBRARY_SUFFIX, RTLD_LAZY);
+        dccl::Codec codec("dccl.ccl.id");
 
         if(!dl_handle)
         {

=== modified file 'src/test/dccl_ccl/test.proto'
--- src/test/dccl_ccl/test.proto	2012-10-24 14:10:06 +0000
+++ src/test/dccl_ccl/test.proto	2014-08-27 16:27:22 +0000
@@ -4,6 +4,7 @@
 {
   option (dccl.msg).id = 1;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   required int32 a = 1 [(dccl.field).min=0,
                         (dccl.field).max=0xFFFF];

=== added directory 'src/test/dccl_codec_group'
=== added file 'src/test/dccl_codec_group/CMakeLists.txt'
--- src/test/dccl_codec_group/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/test/dccl_codec_group/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -0,0 +1,6 @@
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS test.proto)
+
+add_executable(dccl_test_codec_group test.cpp ${PROTO_SRCS} ${PROTO_HDRS})
+target_link_libraries(dccl_test_codec_group dccl)
+
+add_test(dccl_test_codec_group ${dccl_BIN_DIR}/dccl_test_codec_group)

=== added file 'src/test/dccl_codec_group/test.cpp'
--- src/test/dccl_codec_group/test.cpp	1970-01-01 00:00:00 +0000
+++ src/test/dccl_codec_group/test.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,104 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+// tests all protobuf types with _default codecs, repeat and non repeat
+
+#include <fstream>
+
+#include <google/protobuf/descriptor.pb.h>
+
+#include "dccl/codec.h"
+#include "dccl/codecs3/field_codec_default.h"
+
+#include "test.pb.h"
+#include "dccl/binary.h"
+
+template <typename Msg>
+void check(double val, bool should_pass);
+dccl::Codec codec;
+TestMsg msg_in;
+TestMsgGroup msg_group_in;
+
+class TestCodec : public dccl::v3::DefaultNumericFieldCodec<double>
+{
+    double max() { return 100; }
+    double min() { return -100; }
+    double precision() { return 1; }
+    void validate() { }    
+};
+
+    
+
+
+int main(int argc, char* argv[])
+{
+//    dccl::dlog.connect(dccl::logger::ALL, &std::cerr);
+    
+    dccl::FieldCodecManager::add<TestCodec>("test.grouptest");
+    dccl::FieldCodecManager::add<dccl::v3::DefaultMessageCodec, google::protobuf::FieldDescriptor::TYPE_MESSAGE>("test.grouptest");
+    
+    check<TestMsg>(50, true);
+    check<TestMsg>(-50, false);
+    check<TestMsgGroup>(50, true);
+    check<TestMsgGroup>(-50, true);
+    check<TestMsgVersion>(50, true);
+    
+    std::cout << "all tests passed" << std::endl;
+}
+
+
+template <typename Msg>
+void check(double val, bool should_pass)
+{
+    Msg msg_in;
+    int i = 0;
+    msg_in.set_d(++i + 0.1);
+    msg_in.add_d_repeat(12.1);
+    msg_in.add_d_repeat(12.2);
+    msg_in.add_d_repeat(12.3);
+    
+    msg_in.mutable_msg()->set_val(val);
+    msg_in.mutable_msg()->mutable_msg()->set_val(val);
+    codec.info(msg_in.GetDescriptor(), &std::cout);
+
+    std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
+     
+    codec.load(msg_in.GetDescriptor());
+
+    std::cout << "Try encode..." << std::endl;
+    std::string bytes;
+    codec.encode(&bytes, msg_in);
+    std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
+
+    std::cout << "Try decode..." << std::endl;
+    
+    Msg msg_out;
+    codec.decode(bytes, &msg_out);
+    
+    std::cout << "... got Message out:\n" << msg_out.DebugString() << std::endl;
+
+    if(should_pass)
+        assert(msg_in.SerializeAsString() == msg_out.SerializeAsString());
+    else
+        assert(msg_in.SerializeAsString() != msg_out.SerializeAsString());
+}

=== added file 'src/test/dccl_codec_group/test.proto'
--- src/test/dccl_codec_group/test.proto	1970-01-01 00:00:00 +0000
+++ src/test/dccl_codec_group/test.proto	2014-08-27 16:27:22 +0000
@@ -0,0 +1,77 @@
+import "dccl/protobuf/option_extensions.proto";
+
+
+message EmbeddedMsg1
+{
+  option (dccl.msg).codec="dccl.default3";
+  
+  optional double val = 1 [(dccl.field).min=0,
+                           (dccl.field).max=100,
+                           (dccl.field).precision=3];
+
+
+  optional EmbeddedMsg2 msg = 2;
+}
+
+message EmbeddedMsg2
+{
+  optional double val = 1 [(dccl.field).min=0,
+                           (dccl.field).max=100,
+                           (dccl.field).precision=2];
+
+}
+
+message TestMsg
+{
+  option (dccl.msg).id = 1;
+  option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
+  
+  optional double d = 1 [(dccl.field).min=-100,
+                         (dccl.field).max=126,
+                         (dccl.field).precision=1,
+                         (dccl.field).codec="dccl.default3"];
+  
+  
+
+  repeated double d_repeat = 3 [(dccl.field).max_repeat=5,
+                                (dccl.field).codec="test.grouptest"];
+  optional EmbeddedMsg1 msg = 2;
+}
+
+message TestMsgGroup
+{
+  option (dccl.msg).id = 2;
+  option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_group = "test.grouptest";
+  option (dccl.msg).codec_version = 3; 
+  
+  optional double d = 1 [(dccl.field).min=-100,
+                         (dccl.field).max=126,
+                         (dccl.field).precision=1,
+                         (dccl.field).codec="dccl.default3"];
+  
+  repeated double d_repeat = 3 [(dccl.field).max_repeat=5];
+  optional EmbeddedMsg1 msg = 2;
+
+}
+
+
+message TestMsgVersion
+{
+  option (dccl.msg).id = 3;
+  option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 2; 
+  
+  optional double d = 1 [(dccl.field).min=-100,
+                         (dccl.field).max=126,
+                         (dccl.field).precision=2];
+
+  repeated double d_repeat = 3 [(dccl.field).min=12.0,
+                                (dccl.field).max=13.6,
+                                (dccl.field).precision=1,
+                                (dccl.field).max_repeat=5];
+
+  optional EmbeddedMsg1 msg = 2;
+
+}

=== modified file 'src/test/dccl_custom_id/test.proto'
--- src/test/dccl_custom_id/test.proto	2012-10-24 14:10:06 +0000
+++ src/test/dccl_custom_id/test.proto	2014-08-27 16:27:22 +0000
@@ -4,6 +4,7 @@
 {
   option (dccl.msg).id = 1000001;
   option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).codec_version = 3;
   
   required uint32 user = 1 [(dccl.field).min=0,
                             (dccl.field).max=0x03FF,
@@ -14,6 +15,7 @@
 {
   option (dccl.msg).id = 1000002;
   option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).codec_version = 3;
   
   required uint32 clock_mode = 1 [(dccl.field).min=0,
                                   (dccl.field).max=3,
@@ -32,6 +34,7 @@
 {
   option (dccl.msg).id = 1000003;
   option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).codec_version = 3;
   
   required uint32 user = 1 [(dccl.field).min=0,
                             (dccl.field).max=0x03FF,

=== modified file 'src/test/dccl_custom_message/test.proto'
--- src/test/dccl_custom_message/test.proto	2012-10-19 16:41:36 +0000
+++ src/test/dccl_custom_message/test.proto	2014-08-27 16:27:22 +0000
@@ -6,6 +6,7 @@
   option (dccl.msg).id = 3;
   option (dccl.msg).max_bytes = 256;
   option (dccl.msg).codec = "custom_codec";
+  option (dccl.msg).codec_version = 3;
   
   optional uint32 a = 1;
   optional bool b = 2;
@@ -16,6 +17,7 @@
 {
   option (dccl.msg).id = 4;
   option (dccl.msg).max_bytes = 256;
+  option (dccl.msg).codec_version = 3;
 
   optional CustomMsg msg = 1;
   repeated int32 c = 3 [(dccl.field).max=100,

=== modified file 'src/test/dccl_default_id/test.proto'
--- src/test/dccl_default_id/test.proto	2012-10-19 16:41:36 +0000
+++ src/test/dccl_default_id/test.proto	2014-08-27 16:27:22 +0000
@@ -4,12 +4,14 @@
 {
   option (dccl.msg).id = 2;
   option (dccl.msg).max_bytes = 1;
+  option (dccl.msg).codec_version = 3;
 }
 
 message ShortIDMsgWithData
 {
   option (dccl.msg).id = 3;
   option (dccl.msg).max_bytes = 10;
+  option (dccl.msg).codec_version = 3;
 
   optional int32 in_head = 1 [(dccl.field).in_head=true, (dccl.field).min=0, (dccl.field).max=100];
   optional int32 in_body = 2 [(dccl.field).in_head=true, (dccl.field).min=0, (dccl.field).max=100];
@@ -17,23 +19,28 @@
 
 message LongIDMsg
 {
-  option (dccl.msg).id = 10000;  option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).id = 10000;
+  option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).codec_version = 3;
 }
 
 message TooLongIDMsg
 {
   option (dccl.msg).id = 32768;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 }
 
 message LongIDEdgeMsg
 {
   option (dccl.msg).id = 128;
   option (dccl.msg).max_bytes = 2;
+  option (dccl.msg).codec_version = 3;
 }
 
 message ShortIDEdgeMsg
 {
   option (dccl.msg).id = 127;
   option (dccl.msg).max_bytes = 1;
+  option (dccl.msg).codec_version = 3;
 }

=== modified file 'src/test/dccl_header/header.proto'
--- src/test/dccl_header/header.proto	2013-08-22 18:58:12 +0000
+++ src/test/dccl_header/header.proto	2014-08-27 16:27:22 +0000
@@ -11,44 +11,35 @@
   // microseconds since Unix
 
   // second precision (default)
-  required uint64 time = 10 [(dccl.field).codec="_time",
-                             (dccl.field).in_head=true];
-
-  optional int64 time_signed = 20 [(dccl.field).codec="_time",
-                                   (dccl.field).in_head=true];
-  optional double time_double = 21 [(dccl.field).codec="_time",
-                                    (dccl.field).in_head=true];
+  required uint64 time = 10 [(dccl.field).codec="_time"];
+  
+  optional int64 time_signed = 20 [(dccl.field).codec="_time"];
+  optional double time_double = 21 [(dccl.field).codec="_time"];
   optional double pasttime_double = 22 [(dccl.field).codec="_time",
-                                          (dccl.field).num_days=6,
-                                          (dccl.field).in_head=true];  
+                                          (dccl.field).num_days=6];  
   optional double futuretime_double = 23 [(dccl.field).codec="_time",
-                                          (dccl.field).num_days=6,
-                                          (dccl.field).in_head=true];  
+                                          (dccl.field).num_days=6];  
 
   // microsecond precision
   optional int64 time_precision = 24 [(dccl.field).codec="_time",
-                                      (dccl.field).in_head=true,
                                       (dccl.field).precision=-3];
   optional double time_double_precision = 25 [(dccl.field).codec="_time",
-                                              (dccl.field).in_head=true,
                                               (dccl.field).precision=6];
   
   //
   // source
   //
   required int32 source_platform = 11 [(dccl.field).min = 0,
-                                       (dccl.field).max = 31,
-                                       (dccl.field).in_head=true];
+                                       (dccl.field).max = 31];
   optional string source_app = 12 [(dccl.field).omit=true];
   
   //
   // destination
   //
   enum PublishDestination { PUBLISH_SELF = 1; PUBLISH_OTHER = 2; PUBLISH_ALL = 3; }
-  optional PublishDestination dest_type = 13 [default = PUBLISH_SELF, (dccl.field).in_head=true];
+  optional PublishDestination dest_type = 13 [default = PUBLISH_SELF];
   
   optional int32 dest_platform = 14 [(dccl.field).min = 0,
-                                     (dccl.field).max = 31,
-                                     (dccl.field).in_head=true]; // required if dest_type == other
+                                     (dccl.field).max = 31]; // required if dest_type == other
 
 }

=== modified file 'src/test/dccl_header/test.cpp'
--- src/test/dccl_header/test.cpp	2014-04-22 20:13:39 +0000
+++ src/test/dccl_header/test.cpp	2014-08-27 16:27:22 +0000
@@ -24,9 +24,9 @@
 // tests proper encoding of standard Goby header
 
 #include "dccl/codec.h"
-#include "dccl/field_codec_default.h"
 #include "test.pb.h"
 
+#include <sys/time.h>
 
 #include "dccl/binary.h"
 

=== modified file 'src/test/dccl_header/test.proto'
--- src/test/dccl_header/test.proto	2013-08-22 18:24:42 +0000
+++ src/test/dccl_header/test.proto	2014-08-27 16:27:22 +0000
@@ -5,9 +5,10 @@
 {
   option (dccl.msg).id = 4;
   option (dccl.msg).max_bytes = 64;
+  option (dccl.msg).codec_version = 3;
   
   required string telegram = 1 [(dccl.field).max_length=10]; 
-  required Header header = 2;
+  required Header header = 2 [(dccl.field).in_head = true];
 
   optional int32 const_int =3 [(dccl.field).static_value="3", (dccl.field).codec="_static"];
 }

=== added directory 'src/test/dccl_message_fix'
=== added file 'src/test/dccl_message_fix/CMakeLists.txt'
--- src/test/dccl_message_fix/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/test/dccl_message_fix/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -0,0 +1,6 @@
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS test.proto)
+
+add_executable(dccl_test_message_fix test.cpp ${PROTO_SRCS} ${PROTO_HDRS})
+target_link_libraries(dccl_test_message_fix dccl)
+
+add_test(dccl_test_message_fix ${dccl_BIN_DIR}/dccl_test_message_fix)

=== added file 'src/test/dccl_message_fix/test.cpp'
--- src/test/dccl_message_fix/test.cpp	1970-01-01 00:00:00 +0000
+++ src/test/dccl_message_fix/test.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,110 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+// tests all protobuf types with _default codecs, repeat and non repeat
+
+#include <fstream>
+
+#include <google/protobuf/descriptor.pb.h>
+
+#include "dccl/codec.h"
+#include "dccl/codecs2/field_codec_default.h"
+
+#include "test.pb.h"
+#include "dccl/binary.h"
+
+
+int main(int argc, char* argv[])
+{
+//    dccl::dlog.connect(dccl::logger::ALL, &std::cerr);
+    // check the empty messages
+    dccl::Codec codec;
+    
+    codec.info<TestMsg>(&std::cout);
+    codec.load<TestMsg>();
+    
+    {
+        TestMsg msg_in, msg_out;
+        int i = 0;
+
+
+        std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
+     
+        codec.load(msg_in.GetDescriptor());
+
+        std::cout << "Try encode..." << std::endl;
+        std::string bytes;
+        codec.encode(&bytes, msg_in);
+        std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
+
+        std::cout << "Try decode..." << std::endl;
+    
+        codec.decode(bytes, &msg_out);
+    
+        std::cout << "... got Message out:\n" << msg_out.DebugString() << std::endl;
+
+        assert(!msg_out.has_msg1());
+        assert(!msg_out.msg1_repeat_size());    
+        assert(!msg_out.has_msg2());
+        assert(!msg_out.msg2_repeat_size());    
+        assert(msg_in.SerializeAsString() == msg_out.SerializeAsString());
+    }
+
+
+    // check partially full messages
+    {
+        TestMsg msg_in, msg_out;
+
+        msg_in.mutable_msg1()->set_val(0.1);
+        msg_in.add_msg1_repeat()->set_val(0.11);
+        msg_in.add_msg1_repeat()->set_val(0.12);
+        msg_in.add_msg1_repeat()->set_val(0.13);
+        msg_in.mutable_msg2()->set_val(0.2);
+        msg_in.add_msg2_repeat()->set_val(0.21);
+        msg_in.add_msg2_repeat()->set_val(0.22);
+        msg_in.add_msg2_repeat()->set_val(0.23);
+        
+        std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
+
+        std::cout << "Try encode..." << std::endl;
+        std::string bytes;
+        codec.encode(&bytes, msg_in);
+        std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
+
+        std::cout << "Try decode..." << std::endl;
+    
+        codec.decode(bytes, &msg_out);
+    
+        std::cout << "... got Message out:\n" << msg_out.DebugString() << std::endl;
+
+        assert(msg_out.has_msg1());
+        assert(msg_out.msg1_repeat_size() == 3);    
+        assert(msg_out.has_msg2());
+        assert(msg_out.msg2_repeat_size() == 3);    
+        assert(msg_in.SerializeAsString() == msg_out.SerializeAsString());
+    }
+    
+    
+    std::cout << "all tests passed" << std::endl;
+}
+

=== added file 'src/test/dccl_message_fix/test.proto'
--- src/test/dccl_message_fix/test.proto	1970-01-01 00:00:00 +0000
+++ src/test/dccl_message_fix/test.proto	2014-08-27 16:27:22 +0000
@@ -0,0 +1,31 @@
+import "dccl/protobuf/option_extensions.proto";
+
+message EmbeddedMsgOptional
+{
+  optional double val = 1 [(dccl.field).min=0,
+                           (dccl.field).max=126,
+                           (dccl.field).precision=3];
+}
+
+message EmbeddedMsgRequired
+{
+  required double val = 1 [(dccl.field).min=0,
+                           (dccl.field).max=126,
+                           (dccl.field).precision=3];
+}
+
+message TestMsg
+{
+  option (dccl.msg).id = 1;
+  option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
+  
+  optional EmbeddedMsgOptional msg1 = 1;
+  repeated EmbeddedMsgOptional msg1_repeat = 3 [(dccl.field).max_repeat=5];
+
+  // in DCCL v2, these will always be set upon receipt since it has required children. This test validates the fix in v3
+  optional EmbeddedMsgRequired msg2 = 2;
+  repeated EmbeddedMsgRequired msg2_repeat = 4 [(dccl.field).max_repeat=5];
+
+}
+

=== modified file 'src/test/dccl_numeric_bounds/test.proto'
--- src/test/dccl_numeric_bounds/test.proto	2014-03-26 17:27:11 +0000
+++ src/test/dccl_numeric_bounds/test.proto	2014-08-27 16:27:22 +0000
@@ -4,6 +4,7 @@
 {
   option (dccl.msg).id = 10;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional double a = 1 [(dccl.field).max = 180,
                          (dccl.field).min = -180,
@@ -30,6 +31,7 @@
 {
   option (dccl.msg).id = 10;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional double a = 1 [(dccl.field).min = -20,
                          (dccl.field).max = 20,
@@ -45,6 +47,7 @@
 {
   option (dccl.msg).id = 11;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional double a = 1 [(dccl.field).max = 180,
                          (dccl.field).min = -180,

=== modified file 'src/test/dccl_repeated/test.cpp'
--- src/test/dccl_repeated/test.cpp	2014-04-22 20:13:39 +0000
+++ src/test/dccl_repeated/test.cpp	2014-08-27 16:27:22 +0000
@@ -25,7 +25,6 @@
 
 
 #include "dccl/codec.h"
-#include "dccl/field_codec_default.h"
 #include "dccl/binary.h"
 
 #include "test.pb.h"

=== modified file 'src/test/dccl_repeated/test.proto'
--- src/test/dccl_repeated/test.proto	2012-10-23 00:46:12 +0000
+++ src/test/dccl_repeated/test.proto	2014-08-27 16:27:22 +0000
@@ -5,6 +5,7 @@
 {
   option (dccl.msg).id = 4;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional int32 int32_val = 1 [(dccl.field).min=0, (dccl.field).max=20];
 }
@@ -13,6 +14,7 @@
 {
   option (dccl.msg).id = 5;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional bool bool_val = 1;
 }
@@ -21,6 +23,7 @@
 {
   option (dccl.msg).id = 6;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional string string_val = 1 [(dccl.field).max_length=10];
 }

=== modified file 'src/test/dccl_required_optional/test.proto'
--- src/test/dccl_required_optional/test.proto	2012-10-19 16:41:36 +0000
+++ src/test/dccl_required_optional/test.proto	2014-08-27 16:27:22 +0000
@@ -4,6 +4,7 @@
 {
   option (dccl.msg).id = 10;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   required bytes req_bytes = 1 [(dccl.field).max_length=8];
   optional bytes opt_bytes = 2 [(dccl.field).max_length=8];  

=== modified file 'src/test/dccl_static_methods/test.proto'
--- src/test/dccl_static_methods/test.proto	2012-10-23 00:46:12 +0000
+++ src/test/dccl_static_methods/test.proto	2014-08-27 16:27:22 +0000
@@ -5,6 +5,7 @@
 {
   option (dccl.msg).id = 4;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional int32 int32_val = 1 [(dccl.field).min=0, (dccl.field).max=20];
 }
@@ -13,6 +14,7 @@
 {
   option (dccl.msg).id = 5;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional bool bool_val = 1;
 }
@@ -21,6 +23,7 @@
 {
   option (dccl.msg).id = 6;
   option (dccl.msg).max_bytes = 32;
+  option (dccl.msg).codec_version = 3;
 
   optional string string_val = 1 [(dccl.field).max_length=10];
 }

=== added directory 'src/test/dccl_v2_all_fields'
=== added file 'src/test/dccl_v2_all_fields/CMakeLists.txt'
--- src/test/dccl_v2_all_fields/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/test/dccl_v2_all_fields/CMakeLists.txt	2014-08-27 16:27:22 +0000
@@ -0,0 +1,6 @@
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS test.proto)
+
+add_executable(dccl_test_v2_all_fields test.cpp ${PROTO_SRCS} ${PROTO_HDRS})
+target_link_libraries(dccl_test_v2_all_fields dccl)
+
+add_test(dccl_test_v2_all_fields ${dccl_BIN_DIR}/dccl_test_v2_all_fields)

=== added file 'src/test/dccl_v2_all_fields/test.cpp'
--- src/test/dccl_v2_all_fields/test.cpp	1970-01-01 00:00:00 +0000
+++ src/test/dccl_v2_all_fields/test.cpp	2014-08-27 16:27:22 +0000
@@ -0,0 +1,175 @@
+// Copyright 2009-2013 Toby Schneider (https://launchpad.net/~tes)
+//                     Massachusetts Institute of Technology (2007-)
+//                     Woods Hole Oceanographic Institution (2007-)
+//                     DCCL Developers Team (https://launchpad.net/~dccl-dev)
+// 
+//
+// This file is part of the Dynamic Compact Control Language Library
+// ("DCCL").
+//
+// DCCL is free software: you can redistribute them and/or modify
+// them under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DCCL is distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
+
+
+// tests all protobuf types with _default codecs, repeat and non repeat
+
+#include <fstream>
+
+#include <google/protobuf/descriptor.pb.h>
+
+#include "dccl/codec.h"
+#include "test.pb.h"
+#include "dccl/binary.h"
+
+void decode_check(const std::string& encoded);
+dccl::Codec codec;
+TestMsg msg_in;
+
+int main(int argc, char* argv[])
+{
+    dccl::dlog.connect(dccl::logger::ALL, &std::cerr);
+
+    int i = 0;
+    msg_in.set_double_default_optional(++i + 0.1);
+    msg_in.set_float_default_optional(++i + 0.2);
+
+    msg_in.set_int32_default_optional(++i);
+    msg_in.set_int64_default_optional(-++i);
+    msg_in.set_uint32_default_optional(++i);
+    msg_in.set_uint64_default_optional(++i);
+    msg_in.set_sint32_default_optional(-++i);
+    msg_in.set_sint64_default_optional(++i);
+    msg_in.set_fixed32_default_optional(++i);
+    msg_in.set_fixed64_default_optional(++i);
+    msg_in.set_sfixed32_default_optional(++i);
+    msg_in.set_sfixed64_default_optional(-++i);
+
+    msg_in.set_bool_default_optional(true);
+
+    msg_in.set_string_default_optional("abc123");
+    msg_in.set_bytes_default_optional(dccl::hex_decode("00112233aabbcc1234"));
+    
+    msg_in.set_enum_default_optional(ENUM_C);
+    msg_in.mutable_msg_default_optional()->set_val(++i + 0.3);
+    msg_in.mutable_msg_default_optional()->mutable_msg()->set_val(++i);
+
+    msg_in.set_double_default_required(++i + 0.1);
+    msg_in.set_float_default_required(++i + 0.2);
+
+    msg_in.set_int32_default_required(++i);
+    msg_in.set_int64_default_required(-++i);
+    msg_in.set_uint32_default_required(++i);
+    msg_in.set_uint64_default_required(++i);
+    msg_in.set_sint32_default_required(-++i);
+    msg_in.set_sint64_default_required(++i);
+    msg_in.set_fixed32_default_required(++i);
+    msg_in.set_fixed64_default_required(++i);
+    msg_in.set_sfixed32_default_required(++i);
+    msg_in.set_sfixed64_default_required(-++i);
+
+    msg_in.set_bool_default_required(true);
+
+    msg_in.set_string_default_required("abc123");
+    msg_in.set_bytes_default_required(dccl::hex_decode("00112233aabbcc1234"));
+    
+    msg_in.set_enum_default_required(ENUM_C);
+    msg_in.mutable_msg_default_required()->set_val(++i + 0.3);
+    msg_in.mutable_msg_default_required()->mutable_msg()->set_val(++i);
+
+    
+    for(int j = 0; j < 2; ++j)
+    {
+        msg_in.add_double_default_repeat(++i + 0.1);
+        msg_in.add_float_default_repeat(++i + 0.2);
+        
+        msg_in.add_int32_default_repeat(++i);
+        msg_in.add_int64_default_repeat(-++i);
+        msg_in.add_uint32_default_repeat(++i);
+        msg_in.add_uint64_default_repeat(++i);
+        msg_in.add_sint32_default_repeat(-++i);
+        msg_in.add_sint64_default_repeat(++i);
+        msg_in.add_fixed32_default_repeat(++i);
+        msg_in.add_fixed64_default_repeat(++i);
+        msg_in.add_sfixed32_default_repeat(++i);
+        msg_in.add_sfixed64_default_repeat(-++i);
+        
+        msg_in.add_bool_default_repeat(true);
+        
+        msg_in.add_string_default_repeat("abc123");
+
+        if(j)
+            msg_in.add_bytes_default_repeat(dccl::hex_decode("00aabbcc"));
+        else
+            msg_in.add_bytes_default_repeat(dccl::hex_decode("ffeedd12"));
+        
+        msg_in.add_enum_default_repeat(static_cast<Enum1>((++i % 3) + 1));
+        EmbeddedMsg1* em_msg = msg_in.add_msg_default_repeat();
+        em_msg->set_val(++i + 0.3);
+        em_msg->mutable_msg()->set_val(++i);
+    }
+    
+    codec.info(msg_in.GetDescriptor());
+
+    std::ofstream fout("/tmp/testmessage.pb");
+    msg_in.SerializeToOstream(&fout);
+    
+    
+    std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
+     
+    codec.load(msg_in.GetDescriptor());
+
+    std::cout << "Try encode..." << std::endl;
+    std::string bytes;
+    codec.encode(&bytes, msg_in);
+    std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
+
+    std::cout << "Try decode..." << std::endl;
+    decode_check(bytes);
+
+    // make sure DCCL defaults stay wire compatible
+    decode_check(dccl::hex_decode("047f277b9628060000b95660c0b0188000d8c0132858800008000dc2c4c6626466024488cca8ee324bd05c3f23af0000ad9112a09509788013e0820b18e0005ed0204c6c2c4666062042644675975982c65235f10a00ad718a5801000000905f27121600000000a0170050640300309201001a0b00007d320a0000a61a0070b20100a81b00d09c6f0000a0401026361643102636160300f0dfbd5b2280ea2e330f3da59a2100aabfa55a000000000000000000000000"));
+
+    // run a bunch of tests with random strings
+    std::string random = bytes;
+    for(unsigned i = 0; i < 10; ++i)
+    {    
+        random[(rand() % (bytes.size()-1)+1)] = rand() % 256;
+        std::cout << "Using junk bytes: " << dccl::hex_encode(random) << std::endl;
+        
+        try
+        {
+            TestMsg msg_out;
+            codec.decode(random, &msg_out);
+        }
+        catch(dccl::Exception&)
+        {
+        }
+    }
+