Merge lp:~tes/goby/time_fix into lp:goby/trunk

[toby schneider]

1. Consistent source of time based on boost::posix_time. Should be minimal / no use of <ctime> and UNIX double time. Any such use should be flagged as a bug from now on.

2. Renamed and consolidated namespaces:
dccl -> goby::acomms
queue -> goby::acomms
modem -> goby::acomms
micromodem -> goby::acomms
amac -> goby::acomms

tes_util -> goby::util
serial-> goby::util

Renamed a few classes to resolve resulting ambiguity and increase consistency:

dccl::Message* -> DCCLMessage*
modem::Message -> ModemMessage

3. Reworked util libraries:
libstreamlogger + libflexcout -> liblogger
libserial -> libasioclient
tes_utils.h -> time.h / sci.h / string.h

4. Changed header file structure slightly. For example, must #include "goby/acomms/dccl.h" instead of #include "acomms/dccl.h". This reflects the structure for > make install (which puts headers in /usr/local/include/goby/...)

Added courtesy headers for all of goby::acomms and goby::util.

5. Documentation will need to be update to reflect these changes. I still need to do that, but I think we shouldn't have that delay the merge.

[Chris Murphy (chrismurf)]

1) util/time.h still #includes <ctime>, but compiles fine without it. Probably okay to remove it, or is there a dependency I didn't see?

2) seems reasonable to me. I'll probably just do a 'using namespace goby' 99% of the time, but I can live with that. Consistent naming is a good thing.

3) looks good from a quick review.

4) did not review.

5) agreed.

 - c

review: Approve

[Chris Murphy (chrismurf)]

(In summary, looks good, I agree with the philosophy, but obviously didn't do a 100% code review).

[lp:~tes/goby/time_fix]

45. By toby <toby@eis> on 2010-07-15

fixed some Doxygen comments to reflect new namespaces

[toby schneider (tes)]

<ctime> is needed because there are (currently unused) conversions between ptime and time_t in util/time.h. Merged into lp:goby as 43

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2009-12-18 02:50:00 +0000
+++ CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -23,7 +23,7 @@
 
 # set instructions for `make install`
 install(DIRECTORY ${goby_BIN_DIR}/ DESTINATION /usr/local/bin FILE_PERMISSIONS WORLD_EXECUTE)
-install(DIRECTORY ${goby_LIB_DIR}/ DESTINATION /usr/local/lib/goby)
+install(DIRECTORY ${goby_LIB_DIR}/ DESTINATION /usr/local/lib)
 install(DIRECTORY ${goby_INC_DIR}/ DESTINATION /usr/local/include/goby)
 
 # find packages, libraries, and headers
@@ -51,7 +51,7 @@
 # copy to goby/include
 file(GLOB_RECURSE INCLUDE_FILES RELATIVE ${goby_SRC_DIR} src/*.h)
 foreach(I ${INCLUDE_FILES})
-  configure_file(${goby_SRC_DIR}/${I} ${goby_INC_DIR}/${I})
+  configure_file(${goby_SRC_DIR}/${I} ${goby_INC_DIR}/goby/${I})
 endforeach()
 
 # let cmake know where the headers are

=== modified file 'COPYING'
--- COPYING	2010-07-14 22:03:13 +0000
+++ COPYING	2010-07-15 12:38:39 +0000
@@ -2,8 +2,7 @@
 copying goby
 ~~~~~~~~~~~~
 
-goby is copyright 2008, 2009 by
-- t. schneider [e-mail]
+goby is copyright 2008, 2009, 2010 as listed in the individual header files.
 
 see header files of individual components for copyright details.
 

=== added file 'src/acomms.h'
--- src/acomms.h	1970-01-01 00:00:00 +0000
+++ src/acomms.h	2010-07-15 12:38:39 +0000
@@ -0,0 +1,31 @@
+// copyright 2010 t. schneider [e-mail]
+// 
+// this file is part of goby-
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software.  If not, see <http://www.gnu.org/licenses/>.
+
+
+// courtesy header for all the goby acomms libraries
+
+#ifndef ACOMMSCOURTESY20100713H
+#define ACOMMSCOURTESY20100713H
+
+#include "goby/acomms/dccl.h"
+#include "goby/acomms/queue.h"
+#include "goby/acomms/bind.h"
+#include "goby/acomms/modem_driver.h"
+#include "goby/acomms/modem_message.h"
+#include "goby/acomms/amac.h"
+
+#endif

=== modified file 'src/acomms/acomms_constants.h'
--- src/acomms/acomms_constants.h	2010-03-20 06:09:16 +0000
+++ src/acomms/acomms_constants.h	2010-07-15 12:38:39 +0000
@@ -22,61 +22,58 @@
 #include <limits>
 #include <bitset>
 
-#include "util/tes_utils.h"
-
-namespace acomms
+namespace goby
 {
-    const unsigned BITS_IN_BYTE = 8;
-    // one hex char is a nibble (4 bits), two nibbles per byte
-    const unsigned NIBS_IN_BYTE = 2;
-
-    const unsigned BROADCAST_ID = 0;
-    const unsigned char DCCL_CCL_HEADER = 32;
-    
-    const double NaN = std::numeric_limits<double>::quiet_NaN();
-    
-    const unsigned NUM_HEADER_BYTES = 6;
-    const unsigned NUM_HEADER_NIBS = 6*NIBS_IN_BYTE;
-
-    const unsigned NUM_HEADER_PARTS = 8;
-    enum DCCLHeaderPart { head_ccl_id = 0,
-                          head_dccl_id = 1,
-                          head_time = 2,
-                          head_src_id = 3,
-                          head_dest_id = 4,
-                          head_multimessage_flag = 5,
-                          head_broadcast_flag = 6,
-                          head_unused = 7
-    };
-    
-    const std::string DCCL_HEADER_NAMES [] = { "_ccl_id",
-                                               "_id",
-                                               "_time",
-                                               "_src_id",
-                                               "_dest_id",
-                                               "_multimessage_flag",
-                                               "_broadcast_flag",
-                                               "_unused",
-    };
-    inline std::string to_str(DCCLHeaderPart p)
+
+    namespace acomms
     {
-        return DCCL_HEADER_NAMES[p];
+        const unsigned BITS_IN_BYTE = 8;
+        // one hex char is a nibble (4 bits), two nibbles per byte
+        const unsigned NIBS_IN_BYTE = 2;
+
+        const unsigned BROADCAST_ID = 0;
+        const unsigned char DCCL_CCL_HEADER = 32;
+    
+        const double NaN = std::numeric_limits<double>::quiet_NaN();
+        
+        const unsigned DCCL_NUM_HEADER_BYTES = 6;
+
+        const unsigned DCCL_NUM_HEADER_PARTS = 8;
+
+        enum DCCLHeaderPart { head_ccl_id = 0,
+                              head_dccl_id = 1,
+                              head_time = 2,
+                              head_src_id = 3,
+                              head_dest_id = 4,
+                              head_multimessage_flag = 5,
+                              head_broadcast_flag = 6,
+                              head_unused = 7
+        };
+    
+        const std::string DCCL_HEADER_NAMES [] = { "_ccl_id",
+                                                   "_id",
+                                                   "_time",
+                                                   "_src_id",
+                                                   "_dest_id",
+                                                   "_multimessage_flag",
+                                                   "_broadcast_flag",
+                                                   "_unused",
+        };
+        inline std::string to_str(DCCLHeaderPart p)
+        {
+            return DCCL_HEADER_NAMES[p];
+        }
+    
+        enum DCCLHeaderBits { head_ccl_id_size = 8,
+                              head_dccl_id_size = 9,
+                              head_time_size = 17,
+                              head_src_id_size = 5,
+                              head_dest_id_size = 5,
+                              head_flag_size = 1,
+                              head_unused_size = 2
+        };
+    
     }
-    
-    enum DCCLHeaderBits { head_ccl_id_size = 8,
-                          head_dccl_id_size = 9,
-                          head_time_size = 17,
-                          head_src_id_size = 5,
-                          head_dest_id_size = 5,
-                          head_flag_size = 1,
-                          head_unused_size = 2
-    };
-    
-    const double NOT_A_TIME = -1;
 
-    // this is Micro-Modem specific and is used by libmac, therefore
-    // we must get rid of it at some point soon...
-    const unsigned PACKET_SIZE [] = { 32, 32, 64, 256, 256, 256 };
 }
-
 #endif

=== modified file 'src/acomms/amac.h'
--- src/acomms/amac.h	2010-01-16 05:42:56 +0000
+++ src/acomms/amac.h	2010-07-15 12:38:39 +0000
@@ -20,7 +20,7 @@
 #ifndef AMACCOURTESY20091211H
 #define AMACCOURTESY20091211H
 
-#include "acomms/libamac/mac_manager.h"
+#include "goby/acomms/libamac/mac_manager.h"
 
 #endif
 

=== modified file 'src/acomms/bind.h'
--- src/acomms/bind.h	2010-06-15 04:51:47 +0000
+++ src/acomms/bind.h	2010-07-15 12:38:39 +0000
@@ -23,58 +23,57 @@
 
 #include <boost/bind.hpp>
 
-#include "acomms/dccl.h"
-#include "acomms/queue.h"
-#include "acomms/modem_driver.h"
-#include "acomms/amac.h"
+#include "goby/acomms/dccl.h"
+#include "goby/acomms/queue.h"
+#include "goby/acomms/modem_driver.h"
+#include "goby/acomms/amac.h"
 
-/// utilites for dealing with goby-acomms
-namespace acomms_util
+namespace goby
 {
+    namespace acomms
+    {
     
 /// binds the driver link-layer callbacks to the QueueManager
-    void bind(modem::DriverBase& driver, queue::QueueManager& queue_manager)
-    {
-        using boost::bind;
-        driver.set_receive_cb
-            (bind(&queue::QueueManager::receive_incoming_modem_data, &queue_manager, _1));
-        driver.set_ack_cb
-            (bind(&queue::QueueManager::handle_modem_ack, &queue_manager, _1));
-        driver.set_datarequest_cb
-            (bind(&queue::QueueManager::provide_outgoing_modem_data, &queue_manager, _1, _2));
-    }
+        void bind(ModemDriverBase& driver, QueueManager& queue_manager)
+        {
+            using boost::bind;
+            driver.set_receive_cb
+                (bind(&QueueManager::receive_incoming_modem_data, &queue_manager, _1));
+            driver.set_ack_cb
+                (bind(&QueueManager::handle_modem_ack, &queue_manager, _1));
+            driver.set_datarequest_cb
+                (bind(&QueueManager::provide_outgoing_modem_data, &queue_manager, _1, _2));
+        
+            driver.set_destination_cb(boost::bind(&QueueManager::request_next_destination, &queue_manager, _1));
+
+        }
     
 /// binds the MAC initiate transmission callback to the driver and the driver parsed message callback to the MAC
-    void bind(amac::MACManager& mac, modem::DriverBase& driver)
-    {
-        mac.set_initiate_transmission_cb(boost::bind(&modem::DriverBase::initiate_transmission, &driver, _1));
-        mac.set_initiate_ranging_cb(boost::bind(&modem::DriverBase::initiate_ranging, &driver, _1));
-        driver.set_in_parsed_cb(boost::bind(&amac::MACManager::process_message, &mac, _1));
-    }
+        void bind(MACManager& mac, ModemDriverBase& driver)
+        {
+            mac.set_initiate_transmission_cb(boost::bind(&ModemDriverBase::initiate_transmission, &driver, _1));
+            mac.set_initiate_ranging_cb(boost::bind(&ModemDriverBase::initiate_ranging, &driver, _1));
+            mac.set_destination_cb(boost::bind(&ModemDriverBase::request_next_destination, &driver, _1));
+            driver.set_in_parsed_cb(boost::bind(&MACManager::process_message, &mac, _1));
+        }
     
-/// binds the MAC destination request to the queue_manager
-    void bind(amac::MACManager& mac, queue::QueueManager& queue_manager)
-    {
-        mac.set_destination_cb(boost::bind(&queue::QueueManager::request_next_destination, &queue_manager, _1));
-    }
-
-    /// bind all three (shortcut to calling the other three bind functions)
-    void bind(modem::DriverBase& driver, queue::QueueManager& queue_manager, amac::MACManager& mac)
-    {
-        bind(driver, queue_manager);
-        bind(mac, driver);
-        bind(mac, queue_manager);
-    }
-
-    // examples
-    /// \example acomms/examples/chat/chat.cpp
-    /// chat.xml
-    /// \verbinclude chat.xml
-    /// chat.cpp
-
+
+        /// bind all three (shortcut to calling the other three bind functions)
+        void bind(ModemDriverBase& driver, QueueManager& queue_manager, MACManager& mac)
+        {
+            bind(driver, queue_manager);
+            bind(mac, driver);
+        }
+
+        // examples
+        /// \example acomms/examples/chat/chat.cpp
+        /// chat.xml
+        /// \verbinclude chat.xml
+        /// chat.cpp
+
+
+    }
 
 }
 
-
-
 #endif

=== modified file 'src/acomms/dccl.h'
--- src/acomms/dccl.h	2009-12-16 20:12:41 +0000
+++ src/acomms/dccl.h	2010-07-15 12:38:39 +0000
@@ -22,6 +22,6 @@
 #ifndef DCCLCOURTESY20091211H
 #define DCCLCOURTESY20091211H
 
-#include "acomms/libdccl/dccl.h"
+#include "goby/acomms/libdccl/dccl.h"
 
 #endif

=== modified file 'src/acomms/examples/chat/CMakeLists.txt'
--- src/acomms/examples/chat/CMakeLists.txt	2010-01-22 02:52:25 +0000
+++ src/acomms/examples/chat/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(chat chat.cpp chat_curses.cpp)
-target_link_libraries(chat ${Boost_LIBRARIES} queue amac dccl modemdriver)
+target_link_libraries(chat ${Boost_LIBRARIES} goby_queue goby_amac goby_dccl goby_modemdriver)

=== modified file 'src/acomms/examples/chat/chat.cpp'
--- src/acomms/examples/chat/chat.cpp	2010-03-10 01:14:38 +0000
+++ src/acomms/examples/chat/chat.cpp	2010-07-15 12:38:39 +0000
@@ -22,27 +22,29 @@
 
 #include <iostream>
 
-#include "acomms/dccl.h"
-#include "acomms/queue.h"
-#include "acomms/modem_driver.h"
-#include "acomms/amac.h"
-#include "acomms/modem_message.h"
-#include "acomms/bind.h"
+#include "goby/acomms/dccl.h"
+#include "goby/acomms/queue.h"
+#include "goby/acomms/modem_driver.h"
+#include "goby/acomms/amac.h"
+#include "goby/acomms/modem_message.h"
+#include "goby/acomms/bind.h"
 
 #include <boost/lexical_cast.hpp>
 
 #include "chat_curses.h"
 
+using namespace goby::acomms;
+
 int startup_failure();
-void received_data(queue::QueueKey, const modem::Message&);
-void received_ack(queue::QueueKey, const modem::Message&);
+void received_data(QueueKey, const ModemMessage&);
+void received_ack(QueueKey, const ModemMessage&);
 std::string decode_received(unsigned id, const std::string& data);
 
 std::ofstream fout_;
-dccl::DCCLCodec dccl_;
-queue::QueueManager q_manager_(&fout_);
-micromodem::MMDriver mm_driver_(&fout_);
-amac::MACManager mac_(&fout_);
+DCCLCodec dccl_;
+QueueManager q_manager_(&fout_);
+MMDriver mm_driver_(&fout_);
+MACManager mac_(&fout_);
 ChatCurses curses_;
 
 
@@ -77,7 +79,7 @@
     }    
 
     // bind the callbacks of these libraries
-    acomms_util::bind(mm_driver_, q_manager_, mac_);
+    bind(mm_driver_, q_manager_, mac_);
     
     //
     // Initiate DCCL (libdccl)
@@ -100,7 +102,7 @@
     //
     // Initiate medium access control (libamac)
     //
-    mac_.set_type(amac::mac_slotted_tdma);
+    mac_.set_type(mac_slotted_tdma);
     mac_.set_rate(0);
     mac_.set_slot_time(15);
     mac_.set_expire_cycles(5);
@@ -133,7 +135,7 @@
 
         if(!line.empty())
         {
-            std::map<std::string, dccl::MessageVal> vals;
+            std::map<std::string, DCCLMessageVal> vals;
             vals["message"] = line;
 
             std::string hex_out;
@@ -141,7 +143,7 @@
             unsigned message_id = 1;
             dccl_.encode(message_id, hex_out, vals);
             
-            modem::Message message_out;
+            ModemMessage message_out;
             message_out.set_data(hex_out);
             // send this message to my buddy!
             message_out.set_dest(buddy_id);
@@ -171,12 +173,12 @@
     return 1;
 }
 
-void received_data(queue::QueueKey key, const modem::Message& message_in)
+void received_data(QueueKey key, const ModemMessage& message_in)
 {    
     curses_.post_message(message_in.src(), decode_received(key.id(), message_in.data()));
 }
 
-void received_ack(queue::QueueKey key, const modem::Message& ack_message)
+void received_ack(QueueKey key, const ModemMessage& ack_message)
 {
     
     curses_.post_message
@@ -187,7 +189,7 @@
 
 std::string decode_received(unsigned id, const std::string& data)
 {
-    std::map<std::string, dccl::MessageVal> vals;
+    std::map<std::string, DCCLMessageVal> vals;
     dccl_.decode(id, data, vals);
     return vals["message"];
 }

=== modified file 'src/acomms/libamac/CMakeLists.txt'
--- src/acomms/libamac/CMakeLists.txt	2010-01-21 04:25:08 +0000
+++ src/acomms/libamac/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -4,8 +4,8 @@
   include_directories(${Boost_INCLUDE_DIR})
   
   file(GLOB SRC *.cpp *.c)
-  add_library(amac SHARED ${SRC})
-  target_link_libraries(amac streamlogger ${Boost_LIBRARIES})
+  add_library(goby_amac SHARED ${SRC})
+  target_link_libraries(goby_amac goby_logger ${Boost_LIBRARIES})
 endif()
 
 add_subdirectory(examples)
\ No newline at end of file

=== modified file 'src/acomms/libamac/examples/amac_simple/CMakeLists.txt'
--- src/acomms/libamac/examples/amac_simple/CMakeLists.txt	2010-01-22 02:52:25 +0000
+++ src/acomms/libamac/examples/amac_simple/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(amac_simple amac_simple.cpp)
-target_link_libraries(amac_simple amac)
\ No newline at end of file
+target_link_libraries(amac_simple goby_amac)
\ No newline at end of file

=== modified file 'src/acomms/libamac/examples/amac_simple/amac_simple.cpp'
--- src/acomms/libamac/examples/amac_simple/amac_simple.cpp	2010-01-22 02:52:25 +0000
+++ src/acomms/libamac/examples/amac_simple/amac_simple.cpp	2010-07-15 12:38:39 +0000
@@ -13,12 +13,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this software.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "acomms/amac.h"
-#include "acomms/modem_message.h"
+#include "goby/acomms/amac.h"
+#include "goby/acomms/modem_message.h"
 #include <iostream>
 
 int next_dest(unsigned);
-void init_transmission(const modem::Message&);
+void init_transmission(const goby::acomms::ModemMessage&);
 
 int main(int argc, char* argv[])
 {
@@ -26,12 +26,12 @@
     //
     // 1. Create a MACManager and feed it a std::ostream to log to
     //
-    amac::MACManager mac(&std::cout);
+    goby::acomms::MACManager mac(&std::cout);
 
     //
     // 2. Configure it for TDMA with basic peer discovery, rate 0, 10 second slots, and expire vehicles after 2 cycles of no communications. also, we are modem id 1.
     //
-    mac.set_type(amac::mac_slotted_tdma);
+    mac.set_type(goby::acomms::mac_slotted_tdma);
     mac.set_rate(0);
     mac.set_slot_time(10);
     mac.set_expire_cycles(2);
@@ -43,7 +43,7 @@
 
     // give callback for the next destination. this is called before a cycle is initiated, and would be bound to queue::QueueManager::request_next_destination if using libqueue.
     mac.set_destination_cb(&next_dest);
-    // give a callback to use for actually initiating the transmission. this would be bound to modem::DriverBase::initiate_transmission if using libmodemdriver.
+    // give a callback to use for actually initiating the transmission. this would be bound to goby::acomms::ModemDriverBase::initiate_transmission if using libmodemdriver.
     mac.set_initiate_transmission_cb(&init_transmission);
 
     //
@@ -60,8 +60,8 @@
     // 5. Discover some friends (modem ids 2 & 3)
     //
     
-    mac.process_message(modem::Message("src=2"));
-    mac.process_message(modem::Message("src=3"));
+    mac.process_message(goby::acomms::ModemMessage("src=2"));
+    mac.process_message(goby::acomms::ModemMessage("src=3"));
 
     //
     // 6. Run it, hearing consistently from #3, but #2 has gone silent and will be expired after 2 cycles
@@ -71,7 +71,7 @@
     {
         mac.do_work();
         sleep(1);
-        mac.process_message(modem::Message("src=3"));
+        mac.process_message(goby::acomms::ModemMessage("src=3"));
     }
     
     return 0;
@@ -83,7 +83,7 @@
     return 10;
 }
 
-void init_transmission(const modem::Message& init_message)
+void init_transmission(const goby::acomms::ModemMessage& init_message)
 {
     std::cout << "starting transmission with these values: " << init_message << std::endl;
 }

=== modified file 'src/acomms/libamac/mac_manager.cpp'
--- src/acomms/libamac/mac_manager.cpp	2010-07-11 16:20:55 +0000
+++ src/acomms/libamac/mac_manager.cpp	2010-07-15 12:38:39 +0000
@@ -1,4 +1,4 @@
-// copyright 2009 t. schneider [e-mail]
+// copyright 2009, 2010 t. schneider [e-mail]
 // 
 // this file is part of libamac, a medium access control for
 // acoustic networks. 
@@ -27,13 +27,15 @@
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
 
-#include "acomms/modem_message.h"
-#include "acomms/libdccl/dccl_constants.h"
-#include "util/streamlogger.h"
+#include "goby/acomms/modem_message.h"
+#include "goby/acomms/libdccl/dccl_constants.h"
+#include "goby/util/logger.h"
 
 #include "mac_manager.h"
 
-amac::MACManager::MACManager(std::ostream* os /* =0 */)
+using goby::util::goby_time;
+
+goby::acomms::MACManager::MACManager(std::ostream* os /* =0 */)
     : rate_(0),
       slot_time_(15),
       expire_cycles_(5),
@@ -45,34 +47,34 @@
       type_(mac_notype)
 { }
 
-amac::MACManager::~MACManager()
+goby::acomms::MACManager::~MACManager()
 { }
 
-void amac::MACManager::do_work()
+void goby::acomms::MACManager::do_work()
 {
-//    if(os_) *os_ << group("mac") << "timer is running: " << std::boolalpha << timer_is_running_ << std::endl;
+ //    if(os_) *os_ << group("mac") << "timer is running: " << std::boolalpha << timer_is_running_ << std::endl;
     
     // let the io service execute ready handlers (in this case, is the timer up?)
     if(timer_is_running_) io_.poll();
 }
 
-void amac::MACManager::restart_timer()
+void goby::acomms::MACManager::restart_timer()
 {    
     // cancel any old timer jobs waiting
     timer_.cancel();
     timer_.expires_at(next_slot_t_);
-    timer_.async_wait(boost::bind(&amac::MACManager::send_poll, this, _1));
+    timer_.async_wait(boost::bind(&MACManager::send_poll, this, _1));
     timer_is_running_ = true;
 }
 
-void amac::MACManager::stop_timer()
+void goby::acomms::MACManager::stop_timer()
 {
     timer_is_running_ = false;
     timer_.cancel();
 }
 
 
-void amac::MACManager::startup()
+void goby::acomms::MACManager::startup()
 {
     switch(type_)
     {
@@ -80,17 +82,17 @@
             if(os_) *os_ << group("mac")
                          << "Using the Slotted TDMA MAC scheme with autodiscovery"
                          << std::endl;
-            blank_it_ = add_slot(amac::Slot(acomms::BROADCAST_ID,
-                                           amac::Slot::query_destination,
-                                           rate_,
-                                           amac::Slot::slot_data,
-                                           slot_time_,
-                                           boost::posix_time::ptime(boost::posix_time::pos_infin)));
+            blank_it_ = add_slot(Slot(acomms::BROADCAST_ID,
+                                      Slot::query_destination,
+                                      rate_,
+                                      Slot::slot_data,
+                                      slot_time_,
+                                      boost::posix_time::ptime(boost::posix_time::pos_infin)));
 
-            add_slot(amac::Slot(modem_id_,
-                          amac::Slot::query_destination,
+            add_slot(Slot(modem_id_,
+                          Slot::query_destination,
                           rate_,
-                          amac::Slot::slot_data,
+                          Slot::slot_data,
                           slot_time_,
                           boost::posix_time::ptime(boost::posix_time::pos_infin)));
 
@@ -107,7 +109,7 @@
         case mac_polled:
             if(os_) *os_ << group("mac")
                          << "Using the Centralized Polling MAC scheme" << std::endl;
-            next_slot_t_ = now();
+            next_slot_t_ = goby_time();
             break;
 
         default:
@@ -118,7 +120,7 @@
         restart_timer();
 }
 
-void amac::MACManager::send_poll(const asio::error_code& e)
+void goby::acomms::MACManager::send_poll(const asio::error_code& e)
 {    
     // canceled the last timer
     if(e == asio::error::operation_aborted) return;   
@@ -129,7 +131,7 @@
     bool send_poll = true;
     
     int destination = (s.dest() == Slot::query_destination)
-        ? callback_dest(acomms::PACKET_SIZE[s.rate()]) : s.dest();
+        ? callback_dest(s.rate()) : s.dest();
     
     switch(type_)
     {
@@ -157,13 +159,13 @@
         *os_ << " ]" << std::endl;    
 
         *os_ << group("mac") << s.type_as_string() << " slot is starting: {" << s.src() << " to "
-                 << destination << " @ " << s.rate() << "}" << std::endl;
+             << destination << " @ " << s.rate() << "}" << std::endl;
     }
 
     
     if(send_poll)
     {
-        modem::Message m;
+        ModemMessage m;
         switch(s.type())
         {
             case Slot::slot_data:
@@ -214,12 +216,12 @@
     restart_timer();
 }
 
-    boost::posix_time::ptime amac::MACManager::next_cycle_time()
+boost::posix_time::ptime goby::acomms::MACManager::next_cycle_time()
 {
     using namespace boost::gregorian;
     using namespace boost::posix_time;
 
-    int since_day_start = now().time_of_day().total_seconds();
+    int since_day_start = goby_time().time_of_day().total_seconds();
     cycles_since_day_start_ = (floor(since_day_start/cycle_length()) + 1);
 
     if(os_) *os_ << group("mac") << "cycles since day start: "
@@ -232,7 +234,7 @@
     return ptime(day_clock::universal_day(), seconds(secs_to_next));
 }
 
-void amac::MACManager::process_message(const modem::Message& m)
+void goby::acomms::MACManager::process_message(const ModemMessage& m)
 {
     unsigned id = m.src();
     
@@ -249,7 +251,7 @@
         
         slot_order_.push_back
             (id2slot_.insert
-             (std::pair<unsigned, Slot> (id, Slot(id, Slot::query_destination, rate_, Slot::slot_data, slot_time_, now()))));
+             (std::pair<unsigned, Slot> (id, Slot(id, Slot::query_destination, rate_, Slot::slot_data, slot_time_, goby_time()))));
 
         slot_order_.sort();
 
@@ -259,17 +261,17 @@
     {
         std::pair<id2slot_it, id2slot_it> p = id2slot_.equal_range(id);
         for(id2slot_it it = p.first; it != p.second; ++it)
-            it->second.set_last_heard_time(now());
+            it->second.set_last_heard_time(goby_time());
     }
 }
 
-void amac::MACManager::expire_ids()
+void goby::acomms::MACManager::expire_ids()
 {
     bool reset = false;
     
     for(id2slot_it it = id2slot_.begin(), n = id2slot_.end(); it != n; ++it)
     {
-        if(it->second.last_heard_time() < now()-boost::posix_time::seconds(cycle_length()*expire_cycles_) && it->first != modem_id_)
+        if(it->second.last_heard_time() < goby_time()-boost::posix_time::seconds(cycle_length()*expire_cycles_) && it->first != modem_id_)
         {            
             if(os_) *os_ << group("mac") << "removed id " << it->first
                          << " after not hearing for " << expire_cycles_
@@ -284,7 +286,7 @@
     if(reset) process_cycle_size_change();
 }
 
-void amac::MACManager::process_cycle_size_change()
+void goby::acomms::MACManager::process_cycle_size_change()
 {
     next_slot_t_ = next_cycle_time();
     if(os_) *os_ << group("mac") << "the MAC TDMA next cycle begins at time: "
@@ -296,7 +298,7 @@
 }
 
 
-unsigned amac::MACManager::cycle_sum()
+unsigned goby::acomms::MACManager::cycle_sum()
 {
     unsigned s = 0;
     BOOST_FOREACH(id2slot_it it, slot_order_)
@@ -304,7 +306,7 @@
     return s;
 }
 
-void amac::MACManager::position_blank()
+void goby::acomms::MACManager::position_blank()
 {
     unsigned blank_pos = cycle_length() - ((cycles_since_day_start_ % ENTROPY) == (cycle_sum() % ENTROPY)) - 1;
     
@@ -319,11 +321,11 @@
     current_slot_ = slot_order_.begin();
 }
 
-std::map<unsigned, amac::Slot>::iterator amac::MACManager::add_slot(const amac::Slot& s)    
+std::map<unsigned, goby::acomms::Slot>::iterator goby::acomms::MACManager::add_slot(const Slot& s)    
 {
     bool do_timer_start = slot_order_.empty();
 
-    std::map<unsigned, amac::Slot>::iterator it =
+    std::map<unsigned, Slot>::iterator it =
         id2slot_.insert(std::pair<unsigned, Slot>(s.src(), s));
 
     slot_order_.push_back(it);
@@ -333,14 +335,14 @@
     
     if(do_timer_start)
     {
-        next_slot_t_ = now();
+        next_slot_t_ = goby_time();
         restart_timer();
     }
     
     return it;
 }
 
-bool amac::MACManager::remove_slot(const amac::Slot& s)    
+bool goby::acomms::MACManager::remove_slot(const Slot& s)    
 {
     bool removed_a_slot = false;
     

=== modified file 'src/acomms/libamac/mac_manager.h'
--- src/acomms/libamac/mac_manager.h	2010-07-11 16:20:55 +0000
+++ src/acomms/libamac/mac_manager.h	2010-07-15 12:38:39 +0000
@@ -1,4 +1,4 @@
-// copyright 2009 t. schneider [e-mail]
+// copyright 2009, 2010 t. schneider [e-mail]
 // 
 // this file is part of libamac, a medium access control for
 // acoustic networks. 
@@ -23,268 +23,266 @@
 #define MAC20091019H
 
 #include <boost/lexical_cast.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/function.hpp>
 #include "asio.hpp"
 
-namespace modem { class Message; }
+#include "goby/util/time.h"
 
-/// \brief contains the medium access control objects
-///
-/// Use \code #include <goby/acomms/amac.h> \endcode to gain access to all these objects.
-namespace amac
+namespace goby
 {
-    /// \name Acoustic MAC Library callback function type definitions
-    //@{
-
-    /// \brief boost::function for a function taking a unsigned and returning an integer.
-    ///
-    /// Think of this as a generalized version of a function pointer (int (*) (unsigned)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
-    typedef boost::function<int (unsigned)> IdFunc;
-
-    /// \brief boost::function for a function taking a single modem::Message reference.
-    ///
-    /// Think of this as a generalized version of a function pointer (void (*)(modem::Message&)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
-    typedef boost::function<void (const modem::Message & message)> MsgFunc1;
-
-    //@}
+    namespace acomms
+    {
+	class ModemMessage;
+        /// \name Acoustic MAC Library callback function type definitions
+        //@{
+
+        /// \brief boost::function for a function taking a unsigned and returning an integer.
+        ///
+        /// Think of this as a generalized version of a function pointer (int (*) (unsigned)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
+        typedef boost::function<int (unsigned)> MACIdFunc;
+
+        /// \brief boost::function for a function taking a single acomms::ModemMessage reference.
+        ///
+        /// Think of this as a generalized version of a function pointer (void (*)(acomms::ModemMessage&)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
+        typedef boost::function<void (const acomms::ModemMessage & message)> MACMsgFunc1;
+
+        //@}
 
 /// Enumeration of MAC types
-    enum MACType {
-        mac_notype, /*!< no MAC */
-        mac_slotted_tdma, /*!< decentralized time division multiple access */
-        mac_polled /*!< centralized polling */
-    };    
+        enum MACType {
+            mac_notype, /*!< no MAC */
+            mac_slotted_tdma, /*!< decentralized time division multiple access */
+            mac_polled /*!< centralized polling */
+        };    
 
-    /// Represents a slot of the TDMA cycle
-    class Slot
-    {
-      public:
-        /// Enumeration of slot types
-        enum SlotType
+        /// Represents a slot of the TDMA cycle
+        class Slot
         {
-            slot_notype, /*!< useless slot */
-            slot_data, /*!< slot to send data packet */
-            slot_ping /*!< slot to send ping (ranging) */
-        };
+          public:
+            /// Enumeration of slot types
+            enum SlotType
+            {
+                slot_notype, /*!< useless slot */
+                slot_data, /*!< slot to send data packet */
+                slot_ping /*!< slot to send ping (ranging) */
+            };
         
-        /// \name Constructors/Destructor
-        //@{         
-        /// \brief Default constructor.
-        ///
-        /// \param src id representing sender of the data packet or ping
-        /// \param dest id representing destination of the data packet or ping
-        /// \param rate value 0-5 representing modem transmission rate. 0 is slowest, 5 is fastest
-        /// \param type amac::Slot::SlotType of this slot
-        /// \param slot_time length of time this slot should last in seconds
-        /// \param last_heard_time last time (in seconds since 1/1/70) the src vehicle was heard from
-      Slot(unsigned src = 0,
-           unsigned dest = 0,
-           int rate = 0,
-           SlotType type = slot_notype,
-           unsigned slot_time = 15,
-           boost::posix_time::ptime last_heard_time = boost::posix_time::not_a_date_time)
-          : src_(src),
-            dest_(dest),
-            rate_(rate),
-            type_(type),
-            slot_time_(slot_time),
-            last_heard_time_(last_heard_time)        
-            {  }
-
-        //@}
-
-        /// \name Set
-        //@{
-        void set_src(unsigned src) { src_ = src; }
-        void set_dest(int dest) { dest_ = dest; }
-        void set_rate(int rate) { rate_ = rate; }
-        void set_type(SlotType type) { type_ = type; }
-        void set_last_heard_time(boost::posix_time::ptime t) { last_heard_time_ = t; }
-        void set_slot_time(unsigned t) { slot_time_ = t; }
-        //@}
-
-        /// \name Get
-        //@{
-        unsigned src() const { return src_; }
-        int dest() const { return dest_; }
-        int rate() const { return rate_; } 
-        SlotType type() const { return type_; }
-        std::string type_as_string() const
-        {
-            switch(type_)
+            /// \name Constructors/Destructor
+            //@{         
+            /// \brief Default constructor.
+            ///
+            /// \param src id representing sender of the data packet or ping
+            /// \param dest id representing destination of the data packet or ping
+            /// \param rate value 0-5 representing modem transmission rate. 0 is slowest, 5 is fastest
+            /// \param type amac::Slot::SlotType of this slot
+            /// \param slot_time length of time this slot should last in seconds
+            /// \param last_heard_time last time (in seconds since 1/1/70) the src vehicle was heard from
+          Slot(unsigned src = 0,
+               unsigned dest = 0,
+               int rate = 0,
+               SlotType type = slot_notype,
+               unsigned slot_time = 15,
+               boost::posix_time::ptime last_heard_time = boost::posix_time::not_a_date_time)
+              : src_(src),
+                dest_(dest),
+                rate_(rate),
+                type_(type),
+                slot_time_(slot_time),
+                last_heard_time_(last_heard_time)        
+                {  }
+
+            //@}
+
+            /// \name Set
+            //@{
+            void set_src(unsigned src) { src_ = src; }
+            void set_dest(int dest) { dest_ = dest; }
+            void set_rate(int rate) { rate_ = rate; }
+            void set_type(SlotType type) { type_ = type; }
+            void set_last_heard_time(boost::posix_time::ptime t) { last_heard_time_ = t; }
+            void set_slot_time(unsigned t) { slot_time_ = t; }
+            //@}
+
+            /// \name Get
+            //@{
+            unsigned src() const { return src_; }
+            int dest() const { return dest_; }
+            int rate() const { return rate_; } 
+            SlotType type() const { return type_; }
+            std::string type_as_string() const
             {
-                case slot_data: return "data";
-                case slot_ping: return "ping";
-                default: return "unknown";
+                switch(type_)
+                {
+                    case slot_data: return "data";
+                    case slot_ping: return "ping";
+                    default: return "unknown";
+                }
             }
+        
+            boost::posix_time::ptime last_heard_time() const { return last_heard_time_; }
+            unsigned slot_time() const { return slot_time_; }        
+            //@}
+        
+            enum { query_destination = -1 };        
+        
+        
+          private:
+            unsigned src_;
+            int dest_;
+            int rate_;
+            SlotType type_;
+            unsigned slot_time_;
+            boost::posix_time::ptime last_heard_time_;
+        };
+    
+        inline std::ostream& operator<<(std::ostream& os, const Slot& s)
+        { return os << "src: " << s.src() << " | dest: " << s.dest() << " | rate: " << s.rate() << " | slot_time: " << s.slot_time(); }
+
+
+        /// provides an API to the goby-acomms MAC library.
+        class MACManager
+        {
+
+          public:
+
+            /// \name Constructors/Destructor
+            //@{         
+            /// \brief Default constructor.
+            ///
+            /// \param os std::ostream object or FlexOstream to capture all humanly readable runtime and debug information (optional).
+            MACManager(std::ostream* os = 0);
+            ~MACManager();
+            //@}
+        
+            /// \brief Starts the MAC
+            void startup();
+            /// \brief Must be called regularly for the MAC to perform its work
+            void do_work();
+
+            /// \brief Manually initiate a transmission out of the normal cycle. This is not normally called by the user of MACManager
+            void send_poll(const asio::error_code&);
+
+            /// \brief Call every time a message is received from vehicle to "discover" this vehicle or reset the expire timer. Only needed when the type is amac::mac_slotted_tdma.
+            ///
+            /// \param message the new message (used to detect vehicles)
+            void process_message(const acomms::ModemMessage& m);
+
+            /// \name Manipulate slots
+            //@{
+            /// \return iterator to newly added slot
+            std::map<unsigned, Slot>::iterator add_slot(const Slot& s);
+            /// \brief removes any slots in the cycle where amac::operator==(const Slot&, const Slot&) is true.
+            ///
+            /// \return true if one or more slots are removed
+            bool remove_slot(const Slot& s);
+            void clear_all_slots() { id2slot_.clear(); slot_order_.clear(); }    
+            //@}
+
+    
+            /// \name Set
+            //@{    
+            void set_type(MACType type) { type_ = type; }
+            void set_modem_id(unsigned modem_id) { modem_id_ = modem_id; }    
+            void set_modem_id(const std::string& s) { set_modem_id(boost::lexical_cast<unsigned>(s)); }
+            void set_rate(int rate) { rate_ = rate; }
+            void set_rate(const std::string& s) { set_rate(boost::lexical_cast<int>(s)); }
+            void set_slot_time(unsigned slot_time) { slot_time_ = slot_time; }
+            void set_slot_time(const std::string& s) { set_slot_time(boost::lexical_cast<unsigned>(s)); } 
+            void set_expire_cycles(unsigned expire_cycles) { expire_cycles_ = expire_cycles; }
+            void set_expire_cycles(const std::string& s) { set_expire_cycles(boost::lexical_cast<unsigned>(s)); }
+            /// \brief Callback to call to request which vehicle id should be the next destination. Typically bound to queue::QueueManager::request_next_destination.
+            // 
+            // \param func has the form int next_dest(unsigned size). the return value of func should be the next destination id, or -1 for no message to send.
+            void set_destination_cb(MACIdFunc func) { callback_dest = func; }
+            /// \brief Callback for initiate a tranmission. Typically bound to acomms::ModemDriverBase::initiate_transmission. 
+            void set_initiate_transmission_cb(MACMsgFunc1 func) { callback_initiate_transmission = func; }
+
+            /// \brief Callback for initiate ranging ("ping"). Typically bound to acomms::ModemDriverBase::initiate_ranging. 
+            void set_initiate_ranging_cb(MACMsgFunc1 func) { callback_initiate_ranging = func; }
+
+//@}
+
+            /// \name Get
+            //@{    
+            int rate() { return rate_; }
+            unsigned slot_time() { return slot_time_; }        
+            MACType type() { return type_; }
+            //@}
+
+
+            /// \example libamac/examples/amac_simple/amac_simple.cpp
+            /// amac_simple.cpp
+        
+            /// \example acomms/examples/chat/chat.cpp
+        
+          private:
+            enum { NO_AVAILABLE_DESTINATION = -1 };
+            MACIdFunc callback_dest;
+            MACMsgFunc1 callback_initiate_transmission;
+            MACMsgFunc1 callback_initiate_ranging;
+
+            boost::posix_time::ptime next_cycle_time();
+
+            void restart_timer();
+            void stop_timer();
+    
+            void expire_ids();
+            void process_cycle_size_change();
+
+            unsigned cycle_count() { return slot_order_.size(); }
+            unsigned cycle_length() { return cycle_count() * slot_time_; }
+    
+            unsigned cycle_sum();
+            void position_blank();
+    
+          private:
+            // (bit)-rate id number
+            int rate_;
+            // size of each slot (seconds)
+            unsigned slot_time_;
+            // how many cycles before we remove someone?
+            unsigned expire_cycles_;
+    
+            std::ostream* os_;
+    
+            unsigned modem_id_;
+    
+            // asynchronous timer
+            asio::io_service io_;
+            asio::deadline_timer timer_;
+            bool timer_is_running_;
+    
+            boost::posix_time::ptime next_cycle_t_;
+            boost::posix_time::ptime next_slot_t_;
+
+            // <id, last time heard from>
+            typedef std::multimap<unsigned, Slot>::iterator id2slot_it;
+
+            id2slot_it blank_it_;
+            std::list<id2slot_it> slot_order_;
+            std::multimap<unsigned, Slot> id2slot_;
+    
+            std::list<id2slot_it>::iterator current_slot_;
+    
+            unsigned cycles_since_day_start_;    
+    
+            // entropy value used to determine how the "blank" slot moves around relative to the values of the modem ids. determining the proper value for this is a bit of work and i will detail when i have time.
+            enum { ENTROPY = 5 };
+            MACType type_;
+        };
+
+        ///
+        inline bool operator<(const std::map<unsigned, Slot>::iterator& a, const std::map<unsigned, Slot>::iterator& b)
+        { return a->second.src() < b->second.src(); }
+    
+        /// Are two amac::Slot equal?
+        inline bool operator==(const Slot& a, const Slot& b)
+        {
+            return a.src() == b.src() && a.dest() == b.dest() && a.rate() == b.rate() && a.type() == b.type() && a.slot_time() == b.slot_time();
         }
-        
-        boost::posix_time::ptime last_heard_time() const { return last_heard_time_; }
-        unsigned slot_time() const { return slot_time_; }        
-        //@}
-        
-        enum { query_destination = -1 };        
-        
-        
-      private:
-        unsigned src_;
-        int dest_;
-        int rate_;
-        SlotType type_;
-        unsigned slot_time_;
-        boost::posix_time::ptime last_heard_time_;
-    };
-    
-    inline std::ostream& operator<<(std::ostream& os, const Slot& s)
-    { return os << "src: " << s.src() << " | dest: " << s.dest() << " | rate: " << s.rate() << " | slot_time: " << s.slot_time(); }
-
-
-    /// provides an API to the goby-acomms MAC library.
-    class MACManager
-    {
-
-      public:
-
-        /// \name Constructors/Destructor
-        //@{         
-        /// \brief Default constructor.
-        ///
-        /// \param os std::ostream object or FlexOstream to capture all humanly readable runtime and debug information (optional).
-        MACManager(std::ostream* os = 0);
-        ~MACManager();
-        //@}
-        
-        /// \brief Starts the MAC
-        void startup();
-        /// \brief Must be called regularly for the MAC to perform its work
-        void do_work();
-
-        /// \brief Manually initiate a transmission out of the normal cycle. This is not normally called by the user of MACManager
-        void send_poll(const asio::error_code&);
-
-        /// \brief Call every time a message is received from vehicle to "discover" this vehicle or reset the expire timer. Only needed when the type is amac::mac_slotted_tdma.
-        ///
-        /// \param message the new message (used to detect vehicles)
-        void process_message(const modem::Message& m);
-
-        /// \name Manipulate slots
-        //@{
-        /// \return iterator to newly added slot
-        std::map<unsigned, amac::Slot>::iterator add_slot(const amac::Slot& s);
-        /// \brief removes any slots in the cycle where amac::operator==(const Slot&, const Slot&) is true.
-        ///
-        /// \return true if one or more slots are removed
-        bool remove_slot(const amac::Slot& s);
-        void clear_all_slots() { id2slot_.clear(); slot_order_.clear(); }    
-        //@}
-
-    
-        /// \name Set
-        //@{    
-        void set_type(MACType type) { type_ = type; }
-        void set_modem_id(unsigned modem_id) { modem_id_ = modem_id; }    
-        void set_modem_id(const std::string& s) { set_modem_id(boost::lexical_cast<unsigned>(s)); }
-        void set_rate(int rate) { rate_ = rate; }
-        void set_rate(const std::string& s) { set_rate(boost::lexical_cast<int>(s)); }
-        void set_slot_time(unsigned slot_time) { slot_time_ = slot_time; }
-        void set_slot_time(const std::string& s) { set_slot_time(boost::lexical_cast<unsigned>(s)); } 
-        void set_expire_cycles(unsigned expire_cycles) { expire_cycles_ = expire_cycles; }
-        void set_expire_cycles(const std::string& s) { set_expire_cycles(boost::lexical_cast<unsigned>(s)); }
-        /// \brief Callback to call to request which vehicle id should be the next destination. Typically bound to queue::QueueManager::request_next_destination.
-        // 
-        // \param func has the form int next_dest(unsigned size). the return value of func should be the next destination id, or -1 for no message to send.
-        void set_destination_cb(IdFunc func) { callback_dest = func; }
-        /// \brief Callback for initiate a tranmission. Typically bound to modem::DriverBase::initiate_transmission. 
-        void set_initiate_transmission_cb(MsgFunc1 func) { callback_initiate_transmission = func; }
-
-        /// \brief Callback for initiate ranging ("ping"). Typically bound to modem::DriverBase::initiate_ranging. 
-        void set_initiate_ranging_cb(MsgFunc1 func) { callback_initiate_ranging = func; }
-
-//@}
-
-        /// \name Get
-        //@{    
-        int rate() { return rate_; }
-        unsigned slot_time() { return slot_time_; }        
-        MACType type() { return type_; }
-        //@}
-
-
-        /// \example libamac/examples/amac_simple/amac_simple.cpp
-        /// amac_simple.cpp
-        
-        /// \example acomms/examples/chat/chat.cpp
-        
-      private:
-        enum { NO_AVAILABLE_DESTINATION = -1 };
-        IdFunc callback_dest;
-        MsgFunc1 callback_initiate_transmission;
-        MsgFunc1 callback_initiate_ranging;
-
-        boost::posix_time::ptime next_cycle_time();
-
-        void restart_timer();
-        void stop_timer();
-    
-        void expire_ids();
-        void process_cycle_size_change();
-
-        unsigned cycle_count() { return slot_order_.size(); }
-        unsigned cycle_length() { return cycle_count() * slot_time_; }
-    
-        boost::posix_time::ptime now() { return boost::posix_time::second_clock::universal_time(); }    
-        unsigned cycle_sum();
-        void position_blank();
-    
-      private:
-        // (bit)-rate id number
-        int rate_;
-        // size of each slot (seconds)
-        unsigned slot_time_;
-        // how many cycles before we remove someone?
-        unsigned expire_cycles_;
-    
-        std::ostream* os_;
-    
-        unsigned modem_id_;
-    
-        // asynchronous timer
-        asio::io_service io_;
-        asio::deadline_timer timer_;
-        bool timer_is_running_;
-    
-        boost::posix_time::ptime next_cycle_t_;
-        boost::posix_time::ptime next_slot_t_;
-
-        // <id, last time heard from>
-        typedef std::multimap<unsigned, Slot>::iterator id2slot_it;
-
-        id2slot_it blank_it_;
-        std::list<id2slot_it> slot_order_;
-        std::multimap<unsigned, Slot> id2slot_;
-    
-        std::list<id2slot_it>::iterator current_slot_;
-    
-        unsigned cycles_since_day_start_;    
-    
-        // entropy value used to determine how the "blank" slot moves around relative to the values of the modem ids. determining the proper value for this is a bit of work and i will detail when i have time.
-        enum { ENTROPY = 5 };
-        MACType type_;
-    };
-
-    ///
-    inline bool operator<(const std::map<unsigned, Slot>::iterator& a, const std::map<unsigned, Slot>::iterator& b)
-    { return a->second.src() < b->second.src(); }
-    
-    /// Are two amac::Slot equal?
-    inline bool operator==(const Slot& a, const Slot& b)
-    {
-        return a.src() == b.src() && a.dest() == b.dest() && a.rate() == b.rate() && a.type() == b.type() && a.slot_time() == b.slot_time();
+
+
     }
-
-
 }
 
-
 #endif

=== modified file 'src/acomms/libdccl/CMakeLists.txt'
--- src/acomms/libdccl/CMakeLists.txt	2010-03-15 16:21:43 +0000
+++ src/acomms/libdccl/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -4,8 +4,8 @@
   include_directories(${Boost_INCLUDE_DIR})
   
   file(GLOB SRC *.cpp *.c)
-  add_library(dccl SHARED ${SRC})
-  target_link_libraries(dccl xerces-c crypto++)
+  add_library(goby_dccl SHARED ${SRC})
+  target_link_libraries(goby_dccl xerces-c crypto++ ${Boost_LIBRARIES})
 endif()
 
 add_subdirectory(examples)

=== modified file 'src/acomms/libdccl/dccl.cpp'
--- src/acomms/libdccl/dccl.cpp	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/dccl.cpp	2010-07-15 12:38:39 +0000
@@ -26,31 +26,39 @@
 #include "dccl.h"
 #include "message_xml_callbacks.h"
 
+using goby::util::goby_time;
+
 /////////////////////
 // public methods (general use)
 /////////////////////
-dccl::DCCLCodec::DCCLCodec() : start_time_(time(NULL)), modem_id_(0)
+goby::acomms::DCCLCodec::DCCLCodec()
+    : start_time_(goby_time()),
+      modem_id_(0)
 { }
     
-dccl::DCCLCodec::DCCLCodec(const std::string& file, const std::string schema) : start_time_(time(NULL)), modem_id_(0)
+goby::acomms::DCCLCodec::DCCLCodec(const std::string& file, const std::string schema)
+    : start_time_(goby_time()),
+      modem_id_(0)
 { add_xml_message_file(file, schema); }
     
-dccl::DCCLCodec::DCCLCodec(const std::set<std::string>& files,
-                           const std::string schema) : start_time_(time(NULL)), modem_id_(0)
+goby::acomms::DCCLCodec::DCCLCodec(const std::set<std::string>& files,
+                           const std::string schema)
+    : start_time_(goby_time()),
+      modem_id_(0)
 {
     BOOST_FOREACH(const std::string& s, files)
         add_xml_message_file(s, schema);
 }
 
-std::set<unsigned> dccl::DCCLCodec::add_xml_message_file(const std::string& xml_file,
+std::set<unsigned> goby::acomms::DCCLCodec::add_xml_message_file(const std::string& xml_file,
                                                          const std::string xml_schema)
 {
     size_t begin_size = messages_.size();
             
         
     // Register handlers for XML parsing
-    MessageContentHandler content(messages_);
-    MessageErrorHandler error;
+    DCCLMessageContentHandler content(messages_);
+    DCCLMessageErrorHandler error;
     // instantiate a parser for the xml message files
     XMLParser parser(content, error);
     // parse(file, [schema])
@@ -77,59 +85,59 @@
     return added_ids;
 }
 
-std::set<unsigned> dccl::DCCLCodec::all_message_ids()
+std::set<unsigned> goby::acomms::DCCLCodec::all_message_ids()
 {
     std::set<unsigned> s;
-    BOOST_FOREACH(const Message &msg, messages_)
+    BOOST_FOREACH(const DCCLMessage &msg, messages_)
         s.insert(msg.id());
     return s;
 }    
-std::set<std::string> dccl::DCCLCodec::all_message_names()
+std::set<std::string> goby::acomms::DCCLCodec::all_message_names()
 {
     std::set<std::string> s;
-    BOOST_FOREACH(const Message &msg, messages_)
+    BOOST_FOREACH(const DCCLMessage &msg, messages_)
         s.insert(msg.name());
     return s;
 }
 
     
-std::string dccl::DCCLCodec::summary() const	
+std::string goby::acomms::DCCLCodec::summary() const	
 { 
     std::string out;
-    for(std::vector<Message>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    for(std::vector<DCCLMessage>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
         out += it->get_display();
     return out;
 }
 
-std::string dccl::DCCLCodec::brief_summary() const	
+std::string goby::acomms::DCCLCodec::brief_summary() const	
 { 
     std::string out;
-    for(std::vector<Message>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    for(std::vector<DCCLMessage>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
         out += it->get_short_display();
     return out;
 }
 
-void dccl::DCCLCodec::add_algorithm(const std::string& name, AlgFunction1 func)
-{
-    AlgorithmPerformer* ap = AlgorithmPerformer::getInstance();
-    ap -> add_algorithm(name, func);
-}
-
-void dccl::DCCLCodec::add_adv_algorithm(const std::string& name, AlgFunction2 func)
-{
-    AlgorithmPerformer* ap = AlgorithmPerformer::getInstance();
-    ap -> add_algorithm(name, func);
-}
-
-
-std::ostream& dccl::operator<< (std::ostream& out, const DCCLCodec& d)
+void goby::acomms::DCCLCodec::add_algorithm(const std::string& name, AlgFunction1 func)
+{
+    DCCLAlgorithmPerformer* ap = DCCLAlgorithmPerformer::getInstance();
+    ap -> add_algorithm(name, func);
+}
+
+void goby::acomms::DCCLCodec::add_adv_algorithm(const std::string& name, AlgFunction2 func)
+{
+    DCCLAlgorithmPerformer* ap = DCCLAlgorithmPerformer::getInstance();
+    ap -> add_algorithm(name, func);
+}
+
+
+std::ostream& goby::acomms::operator<< (std::ostream& out, const DCCLCodec& d)
 {
     out << d.summary();
     return out;
 }
 
 
-std::ostream& dccl::operator<< (std::ostream& out, const std::set<std::string>& s)
+std::ostream& goby::acomms::operator<< (std::ostream& out, const std::set<std::string>& s)
 {
     out << "std::set<std::string>:" << std::endl;
     for (std::set<std::string>::const_iterator it = s.begin(), n = s.end(); it != n; ++it)
@@ -137,7 +145,7 @@
     return out;
 }
 
-std::ostream& dccl::operator<< (std::ostream& out, const std::set<unsigned>& s)
+std::ostream& goby::acomms::operator<< (std::ostream& out, const std::set<unsigned>& s)
 {
     out << "std::set<unsigned>:" << std::endl;
     for (std::set<unsigned>::const_iterator it = s.begin(), n = s.end(); it != n; ++it)
@@ -155,9 +163,9 @@
 // to be processed. this allows the SAME moos trigger variable
 // to be used to trigger creation of different messages based on the
 // contents of the trigger message itself.
-bool dccl::DCCLCodec::is_publish_trigger(std::set<unsigned>& id, const std::string& key, const std::string& value)
+bool goby::acomms::DCCLCodec::is_publish_trigger(std::set<unsigned>& id, const std::string& key, const std::string& value)
 {
-    for (std::vector<dccl::Message>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    for (std::vector<DCCLMessage>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
     {
         if(key == it->trigger_var() && (it->trigger_mandatory() == "" || value.find(it->trigger_mandatory()) != std::string::npos))
             id.insert(it->id());
@@ -165,11 +173,14 @@
     return (id.empty()) ? false : true;
 }
 
-bool dccl::DCCLCodec::is_time_trigger(std::set<unsigned>& id)
+bool goby::acomms::DCCLCodec::is_time_trigger(std::set<unsigned>& id)
 {
-    for (std::vector<dccl::Message>::iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    using boost::posix_time::seconds;
+    
+    for (std::vector<DCCLMessage>::iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
     {
-        if(it->trigger_type() == "time" && time(NULL) > (start_time_ + it->trigger_number() * it->trigger_time()))
+        if(it->trigger_type() == "time" &&
+           goby_time() > (start_time_ + seconds(it->trigger_number() * it->trigger_time())))
         {
             id.insert(it->id());
             // increment message counter
@@ -181,9 +192,9 @@
 }
 
     
-bool dccl::DCCLCodec::is_incoming(unsigned& id, const std::string& key)
+bool goby::acomms::DCCLCodec::is_incoming(unsigned& id, const std::string& key)
 {
-    for (std::vector<dccl::Message>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    for (std::vector<DCCLMessage>::const_iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
     {
         if (key == it->in_var())
         {
@@ -199,55 +210,55 @@
 /////////////////////
 
 
-void dccl::DCCLCodec::check_duplicates()
+void goby::acomms::DCCLCodec::check_duplicates()
 {
-    std::map<unsigned, std::vector<Message>::iterator> all_ids;
-    for(std::vector<Message>::iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
+    std::map<unsigned, std::vector<DCCLMessage>::iterator> all_ids;
+    for(std::vector<DCCLMessage>::iterator it = messages_.begin(), n = messages_.end(); it != n; ++it)
     {
         unsigned id = it->id();
             
-        std::map<unsigned, std::vector<Message>::iterator>::const_iterator id_it = all_ids.find(id);
+        std::map<unsigned, std::vector<DCCLMessage>::iterator>::const_iterator id_it = all_ids.find(id);
         if(id_it != all_ids.end())
             throw std::runtime_error(std::string("DCCL: duplicate variable id " + boost::lexical_cast<std::string>(id) + " specified for " + it->name() + " and " + id_it->second->name()));
             
-        all_ids.insert(std::pair<unsigned, std::vector<Message>::iterator>(id, it));
+        all_ids.insert(std::pair<unsigned, std::vector<DCCLMessage>::iterator>(id, it));
     }
 }
 
-std::vector<dccl::Message>::const_iterator dccl::DCCLCodec::to_iterator(const std::string& message_name) const
-{
-    if(name2messages_.count(message_name))
-        return messages_.begin() + name2messages_.find(message_name)->second;
-    else
-        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + message_name + "] which is not loaded"));
-}
-std::vector<dccl::Message>::iterator dccl::DCCLCodec::to_iterator(const std::string& message_name)
-{
-    if(name2messages_.count(message_name))
-        return messages_.begin() + name2messages_.find(message_name)->second;
-    else
-        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + message_name + "] which is not loaded"));
-}
-std::vector<dccl::Message>::const_iterator dccl::DCCLCodec::to_iterator(const unsigned& id) const
-{
-    if(id2messages_.count(id))
-        return messages_.begin() + id2messages_.find(id)->second;
-    else
-        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + boost::lexical_cast<std::string>(id) + "] which is not loaded"));
-}
-
-std::vector<dccl::Message>::iterator dccl::DCCLCodec::to_iterator(const unsigned& id)
-{
-    if(id2messages_.count(id))
-        return messages_.begin() + id2messages_.find(id)->second;
-    else
-        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + boost::lexical_cast<std::string>(id) + "] which is not loaded"));
-}
-
-
-void dccl::DCCLCodec::encode_private(std::vector<Message>::iterator it,
+std::vector<goby::acomms::DCCLMessage>::const_iterator goby::acomms::DCCLCodec::to_iterator(const std::string& message_name) const
+{
+    if(name2messages_.count(message_name))
+        return messages_.begin() + name2messages_.find(message_name)->second;
+    else
+        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + message_name + "] which is not loaded"));
+}
+std::vector<goby::acomms::DCCLMessage>::iterator goby::acomms::DCCLCodec::to_iterator(const std::string& message_name)
+{
+    if(name2messages_.count(message_name))
+        return messages_.begin() + name2messages_.find(message_name)->second;
+    else
+        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + message_name + "] which is not loaded"));
+}
+std::vector<goby::acomms::DCCLMessage>::const_iterator goby::acomms::DCCLCodec::to_iterator(const unsigned& id) const
+{
+    if(id2messages_.count(id))
+        return messages_.begin() + id2messages_.find(id)->second;
+    else
+        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + boost::lexical_cast<std::string>(id) + "] which is not loaded"));
+}
+
+std::vector<goby::acomms::DCCLMessage>::iterator goby::acomms::DCCLCodec::to_iterator(const unsigned& id)
+{
+    if(id2messages_.count(id))
+        return messages_.begin() + id2messages_.find(id)->second;
+    else
+        throw std::runtime_error(std::string("DCCL: attempted an operation on message [" + boost::lexical_cast<std::string>(id) + "] which is not loaded"));
+}
+
+
+void goby::acomms::DCCLCodec::encode_private(std::vector<DCCLMessage>::iterator it,
                                      std::string& out,
-                                     std::map<std::string, std::vector<MessageVal> > in /* copy */)
+                                     std::map<std::string, std::vector<DCCLMessageVal> > in /* copy */)
 {
     // 1. encode parts
     std::string body, head;
@@ -267,9 +278,9 @@
     hex_encode(out);
 }
 
-void dccl::DCCLCodec::decode_private(std::vector<Message>::iterator it,
+void goby::acomms::DCCLCodec::decode_private(std::vector<DCCLMessage>::iterator it,
                                      std::string in,
-                                     std::map<std::string, std::vector<MessageVal> >& out)
+                                     std::map<std::string, std::vector<DCCLMessageVal> >& out)
 {
     // 4. hex decode
     hex_decode(in);
@@ -278,9 +289,9 @@
     in.resize(in.find_last_not_of(char(0))+1);
     
     // 3. split body and header (avoid substr::out_of_range)
-    std::string body = (acomms::NUM_HEADER_BYTES < in.size()) ?
-        in.substr(acomms::NUM_HEADER_BYTES) : "";
-    std::string head = in.substr(0, acomms::NUM_HEADER_BYTES);
+    std::string body = (DCCL_NUM_HEADER_BYTES < in.size()) ?
+        in.substr(DCCL_NUM_HEADER_BYTES) : "";
+    std::string head = in.substr(0, DCCL_NUM_HEADER_BYTES);
     
     // 2. decrypt
     if(!crypto_key_.empty()) decrypt(body, head);
@@ -293,33 +304,33 @@
 
 }
         
-void dccl::DCCLCodec::encode_private(std::vector<Message>::iterator it,
-                                     modem::Message& out_msg,
-                                     const std::map<std::string, std::vector<MessageVal> >& in)
+void goby::acomms::DCCLCodec::encode_private(std::vector<DCCLMessage>::iterator it,
+                                             ModemMessage& out_msg,
+                                             const std::map<std::string, std::vector<DCCLMessageVal> >& in)
 {
     std::string out;
     encode_private(it, out, in);
 
-    dccl::DCCLHeaderDecoder head_dec(out);
+    DCCLHeaderDecoder head_dec(out);
 
     out_msg.set_data(out);
     
-    MessageVal& t = head_dec[acomms::head_time];
-    MessageVal& src = head_dec[acomms::head_src_id];
-    MessageVal& dest = head_dec[acomms::head_dest_id];
+    DCCLMessageVal& t = head_dec[head_time];
+    DCCLMessageVal& src = head_dec[head_src_id];
+    DCCLMessageVal& dest = head_dec[head_dest_id];
 
-    out_msg.set_t(long(t));
+    out_msg.set_time(double(t));
     out_msg.set_src(long(src));
     out_msg.set_dest(long(dest));
 }
 
-void dccl::DCCLCodec::decode_private(std::vector<Message>::iterator it,
-                                     const modem::Message& in_msg,
-                                     std::map<std::string,std::vector<MessageVal> >& out)
+void goby::acomms::DCCLCodec::decode_private(std::vector<DCCLMessage>::iterator it,
+                                             const ModemMessage& in_msg,
+                                     std::map<std::string,std::vector<DCCLMessageVal> >& out)
 { decode_private(it, in_msg.data(), out); }
 
 
-void dccl::DCCLCodec::set_crypto_passphrase(const std::string& s)
+void goby::acomms::DCCLCodec::set_crypto_passphrase(const std::string& s)
 {
     using namespace CryptoPP;
 
@@ -328,7 +339,7 @@
 }
 
 
-void dccl::DCCLCodec::encrypt(std::string& s, const std::string& nonce)
+void goby::acomms::DCCLCodec::encrypt(std::string& s, const std::string& nonce)
 {
     using namespace CryptoPP;
 
@@ -346,7 +357,7 @@
     s = cipher;
 }
 
-void dccl::DCCLCodec::decrypt(std::string& s, const std::string& nonce)
+void goby::acomms::DCCLCodec::decrypt(std::string& s, const std::string& nonce)
 {
     using namespace CryptoPP;
 

=== modified file 'src/acomms/libdccl/dccl.h'
--- src/acomms/libdccl/dccl.h	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/dccl.h	2010-07-15 12:38:39 +0000
@@ -1,5 +1,5 @@
 // copyright 2009 t. schneider [e-mail]
-// 
+ // 
 // this file is part of the Dynamic Compact Control Language (DCCL),
 // the goby-acomms codec. goby-acomms is a collection of libraries 
 // for acoustic underwater networking
@@ -20,7 +20,6 @@
 #ifndef DCCL20091211H
 #define DCCL20091211H
 
-#include <ctime>
 #include <string>
 #include <set>
 #include <map>
@@ -28,494 +27,495 @@
 #include <stdexcept>
 #include <vector>
 
-#include "acomms/xml/xml_parser.h"
+#include "goby/acomms/xml/xml_parser.h"
+#include "goby/util/time.h"
 
 #include "message.h"
 #include "message_val.h"
 
-/// \brief contains Dynamic Compact Control Language objects.
-/// 
-/// Use \code #include <goby/acomms/dccl.h> \endcode to gain access to all these objects.
-namespace dccl
+namespace goby
 {
 
-    /// use this for displaying a human readable version
-    template<typename Value>
-        std::ostream& operator<< (std::ostream& out, const std::map<std::string, Value>& m)
-    {
-        typedef std::pair<std::string, Value> P;
-        BOOST_FOREACH(const P& p, m)
-        {
-            out << "\t" << "key: " << p.first << std::endl
-                << "\t" << "value: " << p.second << std::endl;
-        }
-        return out;
-    }
-
-    template<typename Value>
-        std::ostream& operator<< (std::ostream& out, const std::multimap<std::string, Value>& m)
-    {
-        typedef std::pair<std::string, Value> P;
-        BOOST_FOREACH(const P& p, m)
-        {
-            out << "\t" << "key: " << p.first << std::endl
-                << "\t" << "value: " << p.second << std::endl;
-        }
-        return out;
-    }
-
-    
-    /// use this for displaying a human readable version of this STL object
-    std::ostream& operator<< (std::ostream& out, const std::set<unsigned>& s);
-    /// use this for displaying a human readable version of this STL object
-    std::ostream& operator<< (std::ostream& out, const std::set<std::string>& s);
-
-
-    
-    /// provides an API to the Dynamic CCL Codec.
-    class DCCLCodec 
-    {
-      public:
-        /// \name Constructors/Destructor
-        //@{         
-        /// \brief Instantiate with no XML files.
-        DCCLCodec();
-        /// \brief Instantiate with a single XML file.
-        ///
-        /// \param file path to an XML message file (i.e. contains \ref tag_layout and (optionally) \ref tag_publish sections) to parse for use by the codec.
-        /// \param schema path (absolute or relative to the XML file path) for the validating schema (message_schema.xsd) (optional).
-        DCCLCodec(const std::string& file, const std::string schema = "");
-        
-        /// \brief Instantiate with a set of XML files.
-        ///
-        /// \param files set of paths to XML message files to parse for use by the codec.
-        /// \param schema path (absolute or relative to the XML file path) for the validating schema (message_schema.xsd) (optional).
-        DCCLCodec(const std::set<std::string>& files, const std::string schema = "");
-
-        /// destructor
-        ~DCCLCodec() {}
-        //@}
-        
-        /// \name Initialization Methods.
-        ///
-        /// These methods are intended to be called before doing any work with the class. However,
-        /// they may be called at any time as desired.
-        //@{         
-
-        /// \brief Add more messages to this instance of the codec.
-        ///
-        /// \param xml_file path to the xml file to parse and add to this codec.
-        /// \param xml_schema path to the message_schema.xsd file to validate XML with. if using a relative path this
-        /// must be relative to the directory of the xml_file, not the present working directory. if not provided
-        /// no validation is done.
-        /// \return returns id of the last message file parsed. note that there can be more than one message in a file
-        std::set<unsigned> add_xml_message_file(const std::string& xml_file, const std::string xml_schema = "");
-
-        /// \brief Set the schema used for xml syntax checking.
-        /// 
-        /// location is relative to the XML file location!
-        /// if you have XML files in different places you must pass the
-        /// proper relative path (or just use absolute paths)
-        /// \param schema location of the message_schema.xsd file
-        void set_schema(const std::string& schema) { xml_schema_ = schema; }
-
-        /// \brief Set a passphrase for encrypting all messages with
-        /// 
-        /// \param passphrase text passphrase
-        void set_crypto_passphrase(const std::string& passphrase);
-
-        /// \brief Set the %modem id for this vehicle.
-        ///
-        /// \param modem_id unique (within a network) number representing the %modem on this vehicle.
-        void set_modem_id(unsigned modem_id) { modem_id_ = modem_id; }
-
-        
-        
-        /// \brief Add an algorithm callback for a dccl::MessageVal. The return value is stored back into the input parameter (dccl::MessageVal). See test.cpp for an example.
-        ///
-        /// \param name name of the algorithm (\xmltag{... algorithm="name"})
-        /// \param func has the form void name(dccl::MessageVal& val_to_edit) (see dccl::AdvAlgFunction1). can be a function pointer (&name) or
-        /// any function object supported by boost::function (http://www.boost.org/doc/libs/1_34_0/doc/html/function.html)
-        void add_algorithm(const std::string& name, AlgFunction1 func);
-        
-        /// \brief Add an advanced algorithm callback for any DCCL C++ type that may also require knowledge of all the other message variables
-        /// and can optionally have additional parameters
-        ///
-        /// \param name name of the algorithm (\xmltag{... algorithm="name:param1:param2"})
-        /// \param func has the form
-        /// void name(MessageVal& val_to_edit,
-        ///  const std::vector<std::string> params,
-        ///  const std::map<std::string,MessageVal>& vals) (see dccl::AdvAlgFunction3). func can be a function pointer (&name) or
-        /// any function object supported by boost::function (http://www.boost.org/doc/libs/1_34_0/doc/html/function.html).
-        /// \param params (passed to func) a list of colon separated parameters passed by the user in the XML file. param[0] is the name.
-        /// \param vals (passed to func) a map of \ref tag_name to current values for all message variables.
-        void add_adv_algorithm(const std::string& name, AlgFunction2 func);
-        //@}
-        
-        /// \name Codec functions.
-        ///
-        /// This is where the real work happens.
-        //@{         
-        /// \brief Encode a message.
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
-        /// \param hex location for the encoded hexadecimal to be stored. this is suitable for sending to the Micro-Modem
-        /// \param m map of std::string (\ref tag_name) to a vector of dccl::MessageVal representing the values to encode. No fields can be arrays using this call. If fields are arrays, all values but the first in the array will be set to NaN or blank.
-        template<typename Key>
-            void encode(const Key& k, std::string& hex,
-                        const std::map<std::string, MessageVal>& m)
-        {
-            std::map<std::string, std::vector<MessageVal> > vm;
-
-            typedef std::pair<std::string,MessageVal> P;
-            BOOST_FOREACH(const P& p, m)
-                vm.insert(std::pair<std::string,std::vector<MessageVal> >(p.first, p.second));
-            
-            encode_private(to_iterator(k), hex, vm);
-        }
-
-        /// \brief Encode a message.
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
-        /// \param hex location for the encoded hexadecimal to be stored. this is suitable for sending to the Micro-Modem
-        /// \param m map of std::string (\ref tag_name) to a vector of dccl::MessageVal representing the values to encode. Fields can be arrays.
-        template<typename Key>
-            void encode(const Key& k, std::string& hex,
-                        const std::map<std::string, std::vector<MessageVal> >& m)
-        { encode_private(to_iterator(k), hex, m); }
-
-        
-        /// \brief Decode a message.
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message
-        /// \param hex the hexadecimal to be decoded.
-        /// \param m map of std::string (\ref tag_name) to dccl::MessageVal to store the values to be decoded. No fields can be arrays using this call. If fields are arrays, only the first value is returned.
-        template<typename Key>
-            void decode(const Key& k, const std::string& hex,
-                        std::map<std::string, MessageVal>& m)
-        {
-            std::map<std::string, std::vector<MessageVal> > vm;
-
-            decode_private(to_iterator(k), hex, vm);
-            
-            typedef std::pair<std::string,std::vector<MessageVal> > P;
-            BOOST_FOREACH(const P& p, vm)
-                m.insert(std::pair<std::string,MessageVal>(p.first, MessageVal(p.second)));
-        }
-        
-        /// \brief Decode a message.
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message
-        /// \param hex the hexadecimal to be decoded.
-        /// \param m map of std::string (\ref tag_name) to dccl::MessageVal to store the values to be decoded
-        template<typename Key>
-            void decode(const Key& k, const std::string& hex,
-                        std::map<std::string, std::vector<MessageVal> >& m)
-        { decode_private(to_iterator(k), hex, m); }
-
-        
-        //@}
-        
-        /// \name Informational Methods
-        ///
-        //@{         
-        /// long summary of a message for a given Key (std::string name or unsigned id)
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
-        template<typename Key>
-            std::string summary(const Key& k) const
-        { return to_iterator(k)->get_display(); }
-        /// long summary of a message for all loaded messages
-        std::string summary() const;
-
-        /// brief summary of a message for a given Key (std::string name or unsigned id)
-        template<typename Key>
-            std::string brief_summary(const Key& k) const
-        { return to_iterator(k)->get_short_display(); }
-        /// brief summary of a message for all loaded messages
-        std::string brief_summary() const;
-
-        /// how many message are loaded?
-        /// \return number of messages loaded
-        unsigned message_count() { return messages_.size(); }
-
-        /// \return repeat value (number of copies of the message per encode)
-        template<typename Key>
-            unsigned get_repeat(const Key& k)
-        { return to_iterator(k)->repeat(); }
-        
-        /// \return set of all message ids loaded
-        std::set<unsigned> all_message_ids();
-        /// \return set of all message names loaded
-        std::set<std::string> all_message_names();
-        /// \return map of names to DCCL types needed to encode a given message
-        template<typename Key>
-            std::map<std::string, std::string> message_var_names(const Key& k) const
-        { return to_iterator(k)->message_var_names(); }
-        
-        /// \param id message id
-        /// \return name of message
-        std::string id2name(unsigned id) {return to_iterator(id)->name();}
-        /// \param name message name
-        /// \return id of message
-        unsigned name2id(const std::string& name) {return to_iterator(name)->id();}
-        //@}
-
-
-        /// \name Publish/subscribe architecture related methods
-        /// \brief Methods written largely to support DCCL in the context of a publish/subscribe architecture (e.g., see MOOS (http://www.robots.ox.ac.uk/~mobile/MOOS/wiki/pmwiki.php)). The other methods provide a complete interface for encoding and decoding DCCL messages. However, the methods listed here extend the functionality to allow for
-        /// <ul>
-        /// <li> message creation triggering (a message is encoded on a certain event, either time based or publish based) </li>
-        /// <li> encoding that will parse strings of the form: "key1=value,key2=value,key3=value" </li>
-        /// <li> decoding to an arbitrarily formatted string (similar concept to printf) </li>
-        /// </ul>
-        /// These methods will be useful if you are interested in any of the features mentioned above.
-        
-        //@{
-        /// \brief Encode a message using \ref tag_src_var tags instead of \ref tag_name tags
-        ///
-        /// Values can be passed in on one or more maps of names to values, similar to DCCLCodec::encode. 
-        /// Casts are made and string parsing of key=value comma delimited fields is performed.
-        /// This differs substantially from the behavior of encode above.
-        /// For example, take this message variable:
-        /*! \verbatim
-          <int>
-            <name>myint</name>
-            <src_var>somevar</src_var>
-          </int> \endverbatim
-         */
-        ///
-        /// Using this method you can pass vals["somevar"] = "mystring=foo,blah=dog,myint=32"
-        /// or vals["somevar"] = 32.0
-        /// and both cases will properly parse out 32 as the value for this field.
-        /// In comparison, using the normal encode you would pass vals["myint"] = 32
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
-        /// \param msg modem::Message or std::string for encoded message to be stored.
-        /// \param vals map of source variable name to dccl::MessageVal values. 
-        template<typename Key>
-            void pubsub_encode(const Key& k,
-                               modem::Message& msg,
-                               const std::map<std::string, std::vector<dccl::MessageVal> >& pubsub_vals)
- 	{
-            std::vector<dccl::Message>::iterator it = to_iterator(k);
-
-            std::map<std::string, std::vector<dccl::MessageVal> > vals;
-            // clean the pubsub vals into dccl vals
-            // using <src_var/> tag, do casts from double, pull strings from key=value,key=value, etc.
-            BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, it->layout())
-                mv->read_pubsub_vars(vals, pubsub_vals);
-            BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, it->header())
-                mv->read_pubsub_vars(vals, pubsub_vals);
-            
-            encode_private(it, msg, vals);
-        }
-
-        /// \brief Encode a message using \ref tag_src_var tags instead of \ref tag_name tags
-        /// 
-        /// Use this version if you do not have vectors of src_var values
-        template<typename Key>
-            void pubsub_encode(const Key& k,
-                              modem::Message& msg,
-                              const std::map<std::string, MessageVal>& pubsub_vals)
-        {
-            std::map<std::string, std::vector<MessageVal> > vm;
-
-            typedef std::pair<std::string,MessageVal> P;
-            BOOST_FOREACH(const P& p, pubsub_vals)
-                vm.insert(std::pair<std::string,std::vector<MessageVal> >(p.first, p.second));
-            
-            pubsub_encode(k, msg, vm);
-        }
-
-        
-        /// \brief Decode a message using formatting specified in \ref tag_publish tags.
-        ///
-        /// Values will be received in two maps, one of strings and the other of doubles. The \ref tag_publish value will be placed
-        /// either based on the "type" parameter of the \ref tag_publish_var tag (e.g. \<publish_var type="long"\>SOMEVAR\</publish_var\> will be placed as a long). If no type parameter is given and the variable is numeric (e.g. "23242.23") it will be considered a double. If not numeric, it will be considered a string.
-        ///
-        /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
-        /// \param msg modem::Message or std::string to be decode.
-        /// \param vals pointer to std::multimap of publish variable name to std::string values.
-        template<typename Key>
-            void pubsub_decode(const Key& k,
-                               const modem::Message& msg,
-                               std::multimap<std::string, dccl::MessageVal>& pubsub_vals)
+    namespace acomms
+    {
+
+        /// use this for displaying a human readable version
+        template<typename Value>
+            std::ostream& operator<< (std::ostream& out, const std::map<std::string, Value>& m)
+        {
+            typedef std::pair<std::string, Value> P;
+            BOOST_FOREACH(const P& p, m)
+            {
+                out << "\t" << "key: " << p.first << std::endl
+                    << "\t" << "value: " << p.second << std::endl;
+            }
+            return out;
+        }
+
+        template<typename Value>
+            std::ostream& operator<< (std::ostream& out, const std::multimap<std::string, Value>& m)
+        {
+            typedef std::pair<std::string, Value> P;
+            BOOST_FOREACH(const P& p, m)
+            {
+                out << "\t" << "key: " << p.first << std::endl
+                    << "\t" << "value: " << p.second << std::endl;
+            }
+            return out;
+        }
+
+    
+        /// use this for displaying a human readable version of this STL object
+        std::ostream& operator<< (std::ostream& out, const std::set<unsigned>& s);
+        /// use this for displaying a human readable version of this STL object
+        std::ostream& operator<< (std::ostream& out, const std::set<std::string>& s);
+
+
+    
+        /// provides an API to the Dynamic CCL Codec.
+        class DCCLCodec 
+        {
+          public:
+            /// \name Constructors/Destructor
+            //@{         
+            /// \brief Instantiate with no XML files.
+            DCCLCodec();
+            /// \brief Instantiate with a single XML file.
+            ///
+            /// \param file path to an XML message file (i.e. contains \ref tag_layout and (optionally) \ref tag_publish sections) to parse for use by the codec.
+            /// \param schema path (absolute or relative to the XML file path) for the validating schema (message_schema.xsd) (optional).
+            DCCLCodec(const std::string& file, const std::string schema = "");
+        
+            /// \brief Instantiate with a set of XML files.
+            ///
+            /// \param files set of paths to XML message files to parse for use by the codec.
+            /// \param schema path (absolute or relative to the XML file path) for the validating schema (message_schema.xsd) (optional).
+            DCCLCodec(const std::set<std::string>& files, const std::string schema = "");
+
+            /// destructor
+            ~DCCLCodec() {}
+            //@}
+        
+            /// \name Initialization Methods.
+            ///
+            /// These methods are intended to be called before doing any work with the class. However,
+            /// they may be called at any time as desired.
+            //@{         
+
+            /// \brief Add more messages to this instance of the codec.
+            ///
+            /// \param xml_file path to the xml file to parse and add to this codec.
+            /// \param xml_schema path to the message_schema.xsd file to validate XML with. if using a relative path this
+            /// must be relative to the directory of the xml_file, not the present working directory. if not provided
+            /// no validation is done.
+            /// \return returns id of the last message file parsed. note that there can be more than one message in a file
+            std::set<unsigned> add_xml_message_file(const std::string& xml_file, const std::string xml_schema = "");
+
+            /// \brief Set the schema used for xml syntax checking.
+            /// 
+            /// location is relative to the XML file location!
+            /// if you have XML files in different places you must pass the
+            /// proper relative path (or just use absolute paths)
+            /// \param schema location of the message_schema.xsd file
+            void set_schema(const std::string& schema) { xml_schema_ = schema; }
+
+            /// \brief Set a passphrase for encrypting all messages with
+            /// 
+            /// \param passphrase text passphrase
+            void set_crypto_passphrase(const std::string& passphrase);
+
+            /// \brief Set the %modem id for this vehicle.
+            ///
+            /// \param modem_id unique (within a network) number representing the %modem on this vehicle.
+            void set_modem_id(unsigned modem_id) { modem_id_ = modem_id; }
+
+        
+        
+            /// \brief Add an algorithm callback for a MessageVal. The return value is stored back into the input parameter (MessageVal). See test.cpp for an example.
+            ///
+            /// \param name name of the algorithm (\xmltag{... algorithm="name"})
+            /// \param func has the form void name(MessageVal& val_to_edit) (see AdvAlgFunction1). can be a function pointer (&name) or
+            /// any function object supported by boost::function (http://www.boost.org/doc/libs/1_34_0/doc/html/function.html)
+            void add_algorithm(const std::string& name, AlgFunction1 func);
+        
+            /// \brief Add an advanced algorithm callback for any DCCL C++ type that may also require knowledge of all the other message variables
+            /// and can optionally have additional parameters
+            ///
+            /// \param name name of the algorithm (\xmltag{... algorithm="name:param1:param2"})
+            /// \param func has the form
+            /// void name(MessageVal& val_to_edit,
+            ///  const std::vector<std::string> params,
+            ///  const std::map<std::string,MessageVal>& vals) (see AdvAlgFunction3). func can be a function pointer (&name) or
+            /// any function object supported by boost::function (http://www.boost.org/doc/libs/1_34_0/doc/html/function.html).
+            /// \param params (passed to func) a list of colon separated parameters passed by the user in the XML file. param[0] is the name.
+            /// \param vals (passed to func) a map of \ref tag_name to current values for all message variables.
+            void add_adv_algorithm(const std::string& name, AlgFunction2 func);
+            //@}
+        
+            /// \name Codec functions.
+            ///
+            /// This is where the real work happens.
+            //@{         
+            /// \brief Encode a message.
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
+            /// \param hex location for the encoded hexadecimal to be stored. this is suitable for sending to the Micro-Modem
+            /// \param m map of std::string (\ref tag_name) to a vector of MessageVal representing the values to encode. No fields can be arrays using this call. If fields are arrays, all values but the first in the array will be set to NaN or blank.
+            template<typename Key>
+                void encode(const Key& k, std::string& hex,
+                            const std::map<std::string, DCCLMessageVal>& m)
+            {
+                std::map<std::string, std::vector<DCCLMessageVal> > vm;
+
+                typedef std::pair<std::string,DCCLMessageVal> P;
+                BOOST_FOREACH(const P& p, m)
+                    vm.insert(std::pair<std::string,std::vector<DCCLMessageVal> >(p.first, p.second));
+            
+                encode_private(to_iterator(k), hex, vm);
+            }
+
+            /// \brief Encode a message.
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
+            /// \param hex location for the encoded hexadecimal to be stored. this is suitable for sending to the Micro-Modem
+            /// \param m map of std::string (\ref tag_name) to a vector of MessageVal representing the values to encode. Fields can be arrays.
+            template<typename Key>
+                void encode(const Key& k, std::string& hex,
+                            const std::map<std::string, std::vector<DCCLMessageVal> >& m)
+            { encode_private(to_iterator(k), hex, m); }
+
+        
+            /// \brief Decode a message.
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message
+            /// \param hex the hexadecimal to be decoded.
+            /// \param m map of std::string (\ref tag_name) to MessageVal to store the values to be decoded. No fields can be arrays using this call. If fields are arrays, only the first value is returned.
+            template<typename Key>
+                void decode(const Key& k, const std::string& hex,
+                            std::map<std::string, DCCLMessageVal>& m)
+            {
+                std::map<std::string, std::vector<DCCLMessageVal> > vm;
+
+                decode_private(to_iterator(k), hex, vm);
+            
+                typedef std::pair<std::string,std::vector<DCCLMessageVal> > P;
+                BOOST_FOREACH(const P& p, vm)
+                    m.insert(std::pair<std::string,DCCLMessageVal>(p.first, DCCLMessageVal(p.second)));
+            }
+        
+            /// \brief Decode a message.
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message
+            /// \param hex the hexadecimal to be decoded.
+            /// \param m map of std::string (\ref tag_name) to MessageVal to store the values to be decoded
+            template<typename Key>
+                void decode(const Key& k, const std::string& hex,
+                            std::map<std::string, std::vector<DCCLMessageVal> >& m)
+            { decode_private(to_iterator(k), hex, m); }
+
+        
+            //@}
+        
+            /// \name Informational Methods
+            ///
+            //@{         
+            /// long summary of a message for a given Key (std::string name or unsigned id)
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
+            template<typename Key>
+                std::string summary(const Key& k) const
+            { return to_iterator(k)->get_display(); }
+            /// long summary of a message for all loaded messages
+            std::string summary() const;
+
+            /// brief summary of a message for a given Key (std::string name or unsigned id)
+            template<typename Key>
+                std::string brief_summary(const Key& k) const
+            { return to_iterator(k)->get_short_display(); }
+            /// brief summary of a message for all loaded messages
+            std::string brief_summary() const;
+
+            /// how many message are loaded?
+            /// \return number of messages loaded
+            unsigned message_count() { return messages_.size(); }
+
+            /// \return repeat value (number of copies of the message per encode)
+            template<typename Key>
+                unsigned get_repeat(const Key& k)
+            { return to_iterator(k)->repeat(); }
+        
+            /// \return set of all message ids loaded
+            std::set<unsigned> all_message_ids();
+            /// \return set of all message names loaded
+            std::set<std::string> all_message_names();
+            /// \return map of names to DCCL types needed to encode a given message
+            template<typename Key>
+                std::map<std::string, std::string> message_var_names(const Key& k) const
+            { return to_iterator(k)->message_var_names(); }
+        
+            /// \param id message id
+            /// \return name of message
+            std::string id2name(unsigned id) {return to_iterator(id)->name();}
+            /// \param name message name
+            /// \return id of message
+            unsigned name2id(const std::string& name) {return to_iterator(name)->id();}
+            //@}
+
+
+            /// \name Publish/subscribe architecture related methods
+            /// \brief Methods written largely to support DCCL in the context of a publish/subscribe architecture (e.g., see MOOS (http://www.robots.ox.ac.uk/~mobile/MOOS/wiki/pmwiki.php)). The other methods provide a complete interface for encoding and decoding DCCL messages. However, the methods listed here extend the functionality to allow for
+            /// <ul>
+            /// <li> message creation triggering (a message is encoded on a certain event, either time based or publish based) </li>
+            /// <li> encoding that will parse strings of the form: "key1=value,key2=value,key3=value" </li>
+            /// <li> decoding to an arbitrarily formatted string (similar concept to printf) </li>
+            /// </ul>
+            /// These methods will be useful if you are interested in any of the features mentioned above.
+        
+            //@{
+            /// \brief Encode a message using \ref tag_src_var tags instead of \ref tag_name tags
+            ///
+            /// Values can be passed in on one or more maps of names to values, similar to DCCLCodec::encode. 
+            /// Casts are made and string parsing of key=value comma delimited fields is performed.
+            /// This differs substantially from the behavior of encode above.
+            /// For example, take this message variable:
+            /*! \verbatim
+              <int>
+              <name>myint</name>
+              <src_var>somevar</src_var>
+              </int> \endverbatim
+            */
+            ///
+            /// Using this method you can pass vals["somevar"] = "mystring=foo,blah=dog,myint=32"
+            /// or vals["somevar"] = 32.0
+            /// and both cases will properly parse out 32 as the value for this field.
+            /// In comparison, using the normal encode you would pass vals["myint"] = 32
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
+            /// \param msg ModemMessage or std::string for encoded message to be stored.
+            /// \param vals map of source variable name to MessageVal values. 
+            template<typename Key>
+                void pubsub_encode(const Key& k,
+                                   ModemMessage& msg,
+                                   const std::map<std::string, std::vector<DCCLMessageVal> >& pubsub_vals)
+            {
+                std::vector<DCCLMessage>::iterator it = to_iterator(k);
+                
+                std::map<std::string, std::vector<DCCLMessageVal> > vals;
+                // clean the pubsub vals into dccl vals
+                // using <src_var/> tag, do casts from double, pull strings from key=value,key=value, etc.
+                BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, it->layout())
+                    mv->read_pubsub_vars(vals, pubsub_vals);
+                BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, it->header())
+                    mv->read_pubsub_vars(vals, pubsub_vals);
+            
+                encode_private(it, msg, vals);
+            }
+
+            /// \brief Encode a message using \ref tag_src_var tags instead of \ref tag_name tags
+            /// 
+            /// Use this version if you do not have vectors of src_var values
+            template<typename Key>
+                void pubsub_encode(const Key& k,
+                                   ModemMessage& msg,
+                                   const std::map<std::string, DCCLMessageVal>& pubsub_vals)
+            {
+                std::map<std::string, std::vector<DCCLMessageVal> > vm;
+
+                typedef std::pair<std::string,DCCLMessageVal> P;
+                BOOST_FOREACH(const P& p, pubsub_vals)
+                    vm.insert(std::pair<std::string,std::vector<DCCLMessageVal> >(p.first, p.second));
+            
+                pubsub_encode(k, msg, vm);
+            }
+
+        
+            /// \brief Decode a message using formatting specified in \ref tag_publish tags.
+            ///
+            /// Values will be received in two maps, one of strings and the other of doubles. The \ref tag_publish value will be placed
+            /// either based on the "type" parameter of the \ref tag_publish_var tag (e.g. \<publish_var type="long"\>SOMEVAR\</publish_var\> will be placed as a long). If no type parameter is given and the variable is numeric (e.g. "23242.23") it will be considered a double. If not numeric, it will be considered a string.
+            ///
+            /// \param k can either be std::string (the name of the message) or unsigned (the id of the message)
+            /// \param msg ModemMessage or std::string to be decode.
+            /// \param vals pointer to std::multimap of publish variable name to std::string values.
+            template<typename Key>
+                void pubsub_decode(const Key& k,
+                                   const ModemMessage& msg,
+                                   std::multimap<std::string, DCCLMessageVal>& pubsub_vals)
                                
-        {
-            std::vector<dccl::Message>::iterator it = to_iterator(k);
-
-            std::map<std::string, std::vector<dccl::MessageVal> > vals;
-            decode_private(it, msg, vals);
-
-            // go through all the publishes_ and fill in the format strings
-            BOOST_FOREACH(Publish& p, it->publishes())
-                p.write_publish(vals, pubsub_vals);
-        }
-        
-        
-        /// what moos variables do i need to provide to create a message with a call to encode_using_src_vars
-        template<typename Key>
-            std::set<std::string> get_pubsub_src_vars(const Key& k)
-        { return to_iterator(k)->get_pubsub_src_vars(); }
-
-        /// for a given message name, all architecture variables (sources, input, destination, trigger)
-        template<typename Key>
-            std::set<std::string> get_pubsub_all_vars(const Key& k)
-        { return to_iterator(k)->get_pubsub_all_vars(); }
-
-        /// all architecture variables needed for encoding (includes trigger)
-        template<typename Key>
-            std::set<std::string> get_pubsub_encode_vars(const Key& k)
-        { return to_iterator(k)->get_pubsub_encode_vars(); }
-
-        /// for a given message, all architecture variables for decoding (input)
-        template<typename Key>
-            std::set<std::string> get_pubsub_decode_vars(const Key& k)
-        { return to_iterator(k)->get_pubsub_decode_vars(); }
-        
-        /// returns outgoing architecture hexadecimal variable
-        template<typename Key>
-            std::string get_outgoing_hex_var(const Key& k)
-        { return to_iterator(k)->out_var(); }
-
-        /// returns incoming architecture hexadecimal variable
-        template<typename Key>
-            std::string get_incoming_hex_var(const Key& k)
-        { return to_iterator(k)->in_var(); }
-
-        
-        /// \brief look if key / value are trigger for any loaded messages
-        /// if so, store to id and return true
-        bool is_publish_trigger(std::set<unsigned>& id, const std::string& key, const std::string& value);
-
-        /// \brief look if the time is right for trigger for any loaded messages
-        /// if so, store to id and return true
-        bool is_time_trigger(std::set<unsigned>& id);
-
-        /// \brief see if this key is for an incoming message
-        /// if so, return id for decoding
-        bool is_incoming(unsigned& id, const std::string& key);
-        //@}
-
-        
-        // returns a reference to all Message objects.
-
-        // this is only used if one needs more control than DCCLCodec
-        // provides
-        std::vector<Message>& messages() {return messages_;}
-        
-
-        /// \example libdccl/examples/dccl_simple/dccl_simple.cpp
-        /// simple.xml
-        /// \verbinclude dccl_simple/simple.xml
-        /// dccl_simple.cpp
-        
-        /// \example libdccl/examples/plusnet/plusnet.cpp
-        /// nafcon_command.xml
-        /// \verbinclude nafcon_command.xml
-        /// nafcon_report.xml
-        /// \verbinclude nafcon_report.xml
-        /// plusnet.cpp
-        
-        /// \example libdccl/examples/test/test.cpp
-        /// test.xml
-        /// \verbinclude test.xml 
-        /// test.cpp
-        
-        /// \example libdccl/examples/two_message/two_message.cpp
-        /// two_message.xml
-        /// \verbinclude two_message.xml
-        /// two_message.cpp
-
-        /// \example acomms/examples/chat/chat.cpp
-        
-      private:
-        std::vector<Message>::const_iterator to_iterator(const std::string& message_name) const;
-        std::vector<Message>::iterator to_iterator(const std::string& message_name);
-        std::vector<Message>::const_iterator to_iterator(const unsigned& id) const;
-        std::vector<Message>::iterator to_iterator(const unsigned& id);        
-
-        // in map not passed by reference because we want to be able to modify it
-        void encode_private(std::vector<Message>::iterator it,
-                            std::string& out,
-                            std::map<std::string, std::vector<MessageVal> > in);
-
-        // in string not passed by reference because we want to be able to modify it
-        void decode_private(std::vector<Message>::iterator it,
-                            std::string in,
-                            std::map<std::string, std::vector<MessageVal> >& out);
-        
-        void encode_private(std::vector<Message>::iterator it,
-                            modem::Message& out_msg,
-                            const std::map<std::string, std::vector<MessageVal> >& in);
-        
-        void decode_private(std::vector<Message>::iterator it,
-                            const modem::Message& in_msg,
-                            std::map<std::string, std::vector<MessageVal> >& out);
-        
-        void check_duplicates();
-
-        
-        void encrypt(std::string& s, const std::string& nonce);
-        void decrypt(std::string& s, const std::string& nonce);
-        
-      private:
-        std::vector<Message> messages_;
-        std::map<std::string, size_t>  name2messages_;
-        std::map<unsigned, size_t>     id2messages_;
-
-        std::string xml_schema_;
-        time_t start_time_;
-
-        unsigned modem_id_;
-        
-        std::string crypto_key_;
-    };
-
-    /// outputs information about all available messages (same as std::string summary())
-    std::ostream& operator<< (std::ostream& out, const DCCLCodec& d);
-
-
-    class DCCLHeaderEncoder
-    {
-      public:
-        DCCLHeaderEncoder(const std::map<std::string, std::vector<MessageVal> >& in)
-        {
-            std::map<std::string, std::vector<MessageVal> > in_copy = in;
-            msg_.head_encode(encoded_, in_copy);
-            hex_encode(encoded_);
-        }
-        std::string& get() { return encoded_; }
-
-      private:
-        Message msg_;
-        std::string encoded_;        
-    };
-
-    class DCCLHeaderDecoder
-    {
-      public:
-        DCCLHeaderDecoder(const std::string& in_orig)
-        {
-            std::string in = in_orig.substr(0, acomms::NUM_HEADER_NIBS);
-            hex_decode(in);    
-            msg_.head_decode(in, decoded_);
-        }   
-        std::map<std::string, std::vector<MessageVal> >& get() { return decoded_; }
-        MessageVal& operator[] (const std::string& s)
-        { return decoded_[s][0]; }
-        MessageVal& operator[] (acomms::DCCLHeaderPart p)
-        { return decoded_[acomms::to_str(p)][0]; }
-
-        
-      private:
-        Message msg_;
-        std::map<std::string, std::vector<MessageVal> > decoded_;
-    };
+            {
+                std::vector<DCCLMessage>::iterator it = to_iterator(k);
+
+                std::map<std::string, std::vector<DCCLMessageVal> > vals;
+                decode_private(it, msg, vals);
+
+                // go through all the publishes_ and fill in the format strings
+                BOOST_FOREACH(DCCLPublish& p, it->publishes())
+                    p.write_publish(vals, pubsub_vals);
+            }
+        
+        
+            /// what moos variables do i need to provide to create a message with a call to encode_using_src_vars
+            template<typename Key>
+                std::set<std::string> get_pubsub_src_vars(const Key& k)
+            { return to_iterator(k)->get_pubsub_src_vars(); }
+
+            /// for a given message name, all architecture variables (sources, input, destination, trigger)
+            template<typename Key>
+                std::set<std::string> get_pubsub_all_vars(const Key& k)
+            { return to_iterator(k)->get_pubsub_all_vars(); }
+
+            /// all architecture variables needed for encoding (includes trigger)
+            template<typename Key>
+                std::set<std::string> get_pubsub_encode_vars(const Key& k)
+            { return to_iterator(k)->get_pubsub_encode_vars(); }
+
+            /// for a given message, all architecture variables for decoding (input)
+            template<typename Key>
+                std::set<std::string> get_pubsub_decode_vars(const Key& k)
+            { return to_iterator(k)->get_pubsub_decode_vars(); }
+        
+            /// returns outgoing architecture hexadecimal variable
+            template<typename Key>
+                std::string get_outgoing_hex_var(const Key& k)
+            { return to_iterator(k)->out_var(); }
+
+            /// returns incoming architecture hexadecimal variable
+            template<typename Key>
+                std::string get_incoming_hex_var(const Key& k)
+            { return to_iterator(k)->in_var(); }
+
+        
+            /// \brief look if key / value are trigger for any loaded messages
+            /// if so, store to id and return true
+            bool is_publish_trigger(std::set<unsigned>& id, const std::string& key, const std::string& value);
+
+            /// \brief look if the time is right for trigger for any loaded messages
+            /// if so, store to id and return true
+            bool is_time_trigger(std::set<unsigned>& id);
+
+            /// \brief see if this key is for an incoming message
+            /// if so, return id for decoding
+            bool is_incoming(unsigned& id, const std::string& key);
+            //@}
+
+        
+            // returns a reference to all DCCLMessage objects.
+
+            // this is only used if one needs more control than DCCLCodec
+            // provides
+            std::vector<DCCLMessage>& messages() {return messages_;}
+        
+
+            /// \example libdccl/examples/dccl_simple/dccl_simple.cpp
+            /// simple.xml
+            /// \verbinclude dccl_simple/simple.xml
+            /// dccl_simple.cpp
+        
+            /// \example libdccl/examples/plusnet/plusnet.cpp
+            /// nafcon_command.xml
+            /// \verbinclude nafcon_command.xml
+            /// nafcon_report.xml
+            /// \verbinclude nafcon_report.xml
+            /// plusnet.cpp
+        
+            /// \example libdccl/examples/test/test.cpp
+            /// test.xml
+            /// \verbinclude test.xml 
+            /// test.cpp
+        
+            /// \example libdccl/examples/two_message/two_message.cpp
+            /// two_message.xml
+            /// \verbinclude two_message.xml
+            /// two_message.cpp
+
+            /// \example acomms/examples/chat/chat.cpp
+        
+          private:
+            std::vector<DCCLMessage>::const_iterator to_iterator(const std::string& message_name) const;
+            std::vector<DCCLMessage>::iterator to_iterator(const std::string& message_name);
+            std::vector<DCCLMessage>::const_iterator to_iterator(const unsigned& id) const;
+            std::vector<DCCLMessage>::iterator to_iterator(const unsigned& id);        
+
+            // in map not passed by reference because we want to be able to modify it
+            void encode_private(std::vector<DCCLMessage>::iterator it,
+                                std::string& out,
+                                std::map<std::string, std::vector<DCCLMessageVal> > in);
+
+            // in string not passed by reference because we want to be able to modify it
+            void decode_private(std::vector<DCCLMessage>::iterator it,
+                                std::string in,
+                                std::map<std::string, std::vector<DCCLMessageVal> >& out);
+        
+            void encode_private(std::vector<DCCLMessage>::iterator it,
+                                ModemMessage& out_msg,
+                                const std::map<std::string, std::vector<DCCLMessageVal> >& in);
+        
+            void decode_private(std::vector<DCCLMessage>::iterator it,
+                                const ModemMessage& in_msg,
+                                std::map<std::string, std::vector<DCCLMessageVal> >& out);
+        
+            void check_duplicates();
+
+        
+            void encrypt(std::string& s, const std::string& nonce);
+            void decrypt(std::string& s, const std::string& nonce);
+        
+          private:
+            std::vector<DCCLMessage> messages_;
+            std::map<std::string, size_t>  name2messages_;
+            std::map<unsigned, size_t>     id2messages_;
+
+            std::string xml_schema_;
+            boost::posix_time::ptime start_time_;
+
+            unsigned modem_id_;
+        
+            std::string crypto_key_;
+        };
+
+        /// outputs information about all available messages (same as std::string summary())
+        std::ostream& operator<< (std::ostream& out, const DCCLCodec& d);
+
+
+        class DCCLHeaderEncoder
+        {
+          public:
+            DCCLHeaderEncoder(const std::map<std::string, std::vector<DCCLMessageVal> >& in)
+            {
+                std::map<std::string, std::vector<DCCLMessageVal> > in_copy = in;
+                msg_.head_encode(encoded_, in_copy);
+                hex_encode(encoded_);
+            }
+            std::string& get() { return encoded_; }
+
+          private:
+            DCCLMessage msg_;
+            std::string encoded_;        
+        };
+
+        class DCCLHeaderDecoder
+        {
+          public:
+            DCCLHeaderDecoder(const std::string& in_orig)
+            {
+                std::string in = in_orig.substr(0, DCCL_NUM_HEADER_BYTES*NIBS_IN_BYTE);
+                hex_decode(in);    
+                msg_.head_decode(in, decoded_);
+            }   
+            std::map<std::string, std::vector<DCCLMessageVal> >& get() { return decoded_; }
+            DCCLMessageVal& operator[] (const std::string& s)
+            { return decoded_[s][0]; }
+            DCCLMessageVal& operator[] (DCCLHeaderPart p)
+            { return decoded_[to_str(p)][0]; }
+
+        
+          private:
+            DCCLMessage msg_;
+            std::map<std::string, std::vector<DCCLMessageVal> > decoded_;
+        };
 
     
+    }
 }
 
 
-
 #endif

=== modified file 'src/acomms/libdccl/dccl_constants.h'
--- src/acomms/libdccl/dccl_constants.h	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/dccl_constants.h	2010-07-15 12:38:39 +0000
@@ -28,9 +28,12 @@
 #include <crypto++/filters.h>
 #include <crypto++/hex.h>
 
-#include "acomms/acomms_constants.h"
-
-namespace dccl
+#include "goby/acomms/acomms_constants.h"
+
+namespace goby
+{
+
+namespace acomms
 {
 
 /// Enumeration of DCCL types used for sending messages. dccl_enum and dccl_string primarily map to cpp_string, dccl_bool to cpp_bool, dccl_int to cpp_long, dccl_float to cpp_double
@@ -111,5 +114,5 @@
     
 
 }
-
+}
 #endif

=== modified file 'src/acomms/libdccl/examples/dccl_simple/CMakeLists.txt'
--- src/acomms/libdccl/examples/dccl_simple/CMakeLists.txt	2010-01-22 02:52:25 +0000
+++ src/acomms/libdccl/examples/dccl_simple/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(dccl_simple dccl_simple.cpp)
-target_link_libraries(dccl_simple dccl)
\ No newline at end of file
+target_link_libraries(dccl_simple goby_dccl)
\ No newline at end of file

=== modified file 'src/acomms/libdccl/examples/dccl_simple/dccl_simple.cpp'
--- src/acomms/libdccl/examples/dccl_simple/dccl_simple.cpp	2010-03-15 16:21:43 +0000
+++ src/acomms/libdccl/examples/dccl_simple/dccl_simple.cpp	2010-07-15 12:38:39 +0000
@@ -17,17 +17,17 @@
 // encodes/decodes a string using the DCCL codec library
 // assumes prior knowledge of the message format (required fields)
 
-#include "acomms/dccl.h"
+#include "goby/acomms/dccl.h"
 #include <iostream>
 
-using dccl::operator<<;
+using goby::acomms::operator<<;
 
 int main()
 {
     // initialize input contents to encoder. since
     // simple.xml only has a <string/> message var
     // we only need one map.
-    std::map<std::string, dccl::MessageVal> val_map;
+    std::map<std::string, goby::acomms::DCCLMessageVal> val_map;
 
     //  initialize output hexadecimal
     std::string hex;
@@ -37,7 +37,7 @@
     // instantiate the parser with a single xml file (simple.xml).
     // also pass the schema, relative to simple.xml, for XML validity
     // checking (syntax).
-    dccl::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/dccl_simple/simple.xml",
+    goby::acomms::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/dccl_simple/simple.xml",
                          "../../message_schema.xsd");
 
     

=== modified file 'src/acomms/libdccl/examples/delta/CMakeLists.txt'
--- src/acomms/libdccl/examples/delta/CMakeLists.txt	2010-03-05 03:32:48 +0000
+++ src/acomms/libdccl/examples/delta/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(delta delta.cpp)
-target_link_libraries(delta dccl)
\ No newline at end of file
+target_link_libraries(delta goby_dccl)
\ No newline at end of file

=== modified file 'src/acomms/libdccl/examples/delta/delta.cpp'
--- src/acomms/libdccl/examples/delta/delta.cpp	2010-03-10 01:14:38 +0000
+++ src/acomms/libdccl/examples/delta/delta.cpp	2010-07-15 12:38:39 +0000
@@ -17,22 +17,22 @@
 // encodes/decodes several fields using delta encoding
 
 
-#include "acomms/dccl.h"
+#include "goby/acomms/dccl.h"
 #include <iostream>
 
-using dccl::operator<<;
+using goby::acomms::operator<<;
 
 int main()
 {
-    std::vector< std::map<std::string, dccl::MessageVal> > vals_vect;
-    std::map<std::string, dccl::MessageVal> vals;
+    std::vector< std::map<std::string, acomms::DCCLMessageVal> > vals_vect;
+    std::map<std::string, acomms::DCCLMessageVal> vals;
     
     //  initialize output hexadecimal
     std::string hex;
     
     std::cout << "loading xml file: delta.xml" << std::endl;
 
-    dccl::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/delta/delta.xml",
+    goby::acomms::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/delta/delta.xml",
                          "../../message_schema.xsd");
 
     std::cout << dccl << std::endl;
@@ -77,7 +77,7 @@
 
 //    dccl.delta_decode(1, hex, 0, &vals_vect, 0, 0);
     
-    for(std::vector< std::map<std::string, dccl::MessageVal> >::iterator
+    for(std::vector< std::map<std::string, acomms::DCCLMessageVal> >::iterator
             it = vals_vect.begin(),
             n = vals_vect.end();
         it != n;

=== modified file 'src/acomms/libdccl/examples/plusnet/CMakeLists.txt'
--- src/acomms/libdccl/examples/plusnet/CMakeLists.txt	2009-12-18 02:50:00 +0000
+++ src/acomms/libdccl/examples/plusnet/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(plusnet plusnet.cpp)
-target_link_libraries(plusnet dccl)
+target_link_libraries(plusnet goby_dccl)

=== modified file 'src/acomms/libdccl/examples/plusnet/plusnet.cpp'
--- src/acomms/libdccl/examples/plusnet/plusnet.cpp	2010-03-20 06:09:16 +0000
+++ src/acomms/libdccl/examples/plusnet/plusnet.cpp	2010-07-15 12:38:39 +0000
@@ -20,18 +20,19 @@
 
 // this is an example showing some of the "MOOS" related features of libdccl that can be used (if desired) in the absence of MOOS
 
-#include "acomms/dccl.h"
+#include "goby/acomms/dccl.h"
 
 #include <exception>
 #include <iostream>
 
-using dccl::operator<<;
+using namespace goby;
+using goby::acomms::operator<<;
 
 int main()
 {
     std::cout << "loading nafcon xml files" << std::endl;
 
-    dccl::DCCLCodec dccl;
+    acomms::DCCLCodec dccl;
     dccl.add_xml_message_file(DCCL_EXAMPLES_DIR "/plusnet/nafcon_command.xml", "../../message_schema.xsd");
     dccl.add_xml_message_file(DCCL_EXAMPLES_DIR "/plusnet/nafcon_report.xml", "../../message_schema.xsd");
     
@@ -45,10 +46,10 @@
               << std::string(30, '#') << std::endl;
 
     // initialize input contents to encoder
-    std::map<std::string, dccl::MessageVal> in_vals;
+    std::map<std::string, acomms::DCCLMessageVal> in_vals;
 
     // initialize output message
-    modem::Message msg;
+    acomms::ModemMessage msg;
 
     in_vals["PLUSNET_MESSAGES"] = "MessageType=SENSOR_STATUS,SensorReportType=0,SourcePlatformId=1,DestinationPlatformId=3,Timestamp=1191947446.91117,NodeLatitude=47.7448,NodeLongitude=-122.845,NodeDepth=0.26,NodeCEP=0,NodeHeading=169.06,NodeSpeed=0,MissionState=2,MissionType=2,LastGPSTimestamp=1191947440,PowerLife=6,SensorHealth=0,RecorderState=1,RecorderLife=0,NodeSpecificInfo0=0,NodeSpecificInfo1=0,NodeSpecificInfo2=23,NodeSpecificInfo3=0,NodeSpecificInfo4=3,NodeSpecificInfo5=0";
 
@@ -57,15 +58,15 @@
     
     dccl.pubsub_encode("SENSOR_STATUS", msg, in_vals);
     
-    std::cout << "received dccl::Message: "
+    std::cout << "received acomms::DCCLMessage: "
               << msg.serialize()
               << std::endl;
 
     
-    std::multimap<std::string, dccl::MessageVal> out_vals;
+    std::multimap<std::string, acomms::DCCLMessageVal> out_vals;
 
     
-    std::cout << "passed dccl::Message to decoder: " 
+    std::cout << "passed acomms::DCCLMessage to decoder: " 
               << msg.serialize()
               << std::endl;
 

=== modified file 'src/acomms/libdccl/examples/test/CMakeLists.txt'
--- src/acomms/libdccl/examples/test/CMakeLists.txt	2009-12-02 05:18:28 +0000
+++ src/acomms/libdccl/examples/test/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(dccl_test test.cpp)
-target_link_libraries(dccl_test dccl)
\ No newline at end of file
+target_link_libraries(dccl_test goby_dccl)
\ No newline at end of file

=== modified file 'src/acomms/libdccl/examples/test/test.cpp'
--- src/acomms/libdccl/examples/test/test.cpp	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/examples/test/test.cpp	2010-07-15 12:38:39 +0000
@@ -14,41 +14,42 @@
 // along with this software.  If not, see <http://www.gnu.org/licenses/>.
 
 
-#include "acomms/dccl.h"
+#include "goby/acomms/dccl.h"
 #include <iostream>
 #include <cassert>
 
-using dccl::operator<<;
+using namespace goby;
+using goby::acomms::operator<<;
 
-void plus1(dccl::MessageVal& mv)
+void plus1(acomms::DCCLMessageVal& mv)
 {
     long l = mv;
     ++l;
     mv = l;
 }
 
-void times2(dccl::MessageVal& mv)
+void times2(acomms::DCCLMessageVal& mv)
 {
     double d = mv;
     d *= 2;
     mv = d;
 }
 
-void prepend_fat(dccl::MessageVal& mv)
+void prepend_fat(acomms::DCCLMessageVal& mv)
 {
     std::string s = mv;
     s = "fat_" + s;
     mv = s;
 }
 
-void invert(dccl::MessageVal& mv)
+void invert(acomms::DCCLMessageVal& mv)
 {
     bool b = mv;
     b ^= 1;
     mv = b;
 }
 
-void algsum(dccl::MessageVal& mv, const std::vector<dccl::MessageVal>& ref_vals)
+void algsum(acomms::DCCLMessageVal& mv, const std::vector<acomms::DCCLMessageVal>& ref_vals)
 {
     double d = 0;
     // index 0 is the name ("sum"), so start at 1
@@ -65,7 +66,7 @@
     std::cout << "loading xml file: test.xml" << std::endl;
 
     // instantiate the parser with a single xml file
-    dccl::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/test/test.xml", "../../message_schema.xsd");
+    acomms::DCCLCodec dccl(DCCL_EXAMPLES_DIR "/test/test.xml", "../../message_schema.xsd");
 
     std::cout << dccl << std::endl;
     
@@ -79,32 +80,32 @@
     // must be kept secret!
     dccl.set_crypto_passphrase("my_passphrase!");
     
-    std::map<std::string, std::vector<dccl::MessageVal> > in;
+    std::map<std::string, std::vector<acomms::DCCLMessageVal> > in;
     
     bool b = true; 
-    std::vector<dccl::MessageVal> e;
+    std::vector<acomms::DCCLMessageVal> e;
     e.push_back("dog");
     e.push_back("cat");
     e.push_back("emu");
     
     std::string s = "raccoon";  
-    std::vector<dccl::MessageVal> i;
+    std::vector<acomms::DCCLMessageVal> i;
     i.push_back(30);
     i.push_back(40);
-    std::vector<dccl::MessageVal> f;
+    std::vector<acomms::DCCLMessageVal> f;
     f.push_back(-12.5);
     f.push_back(1);
     
     std::string h = "abcd1234"; 
-    std::vector<dccl::MessageVal> sum(2,0);
-    
-    
-    in["B"] = std::vector<dccl::MessageVal>(1,b);
+    std::vector<acomms::DCCLMessageVal> sum(2,0);
+    
+    
+    in["B"] = std::vector<acomms::DCCLMessageVal>(1,b);
     in["E"] = e;
-    in["S"] = std::vector<dccl::MessageVal>(1,s);
+    in["S"] = std::vector<acomms::DCCLMessageVal>(1,s);
     in["I"] = i;
     in["F"] = f;
-    in["H"] = std::vector<dccl::MessageVal>(1,h);
+    in["H"] = std::vector<acomms::DCCLMessageVal>(1,h);
     in["SUM"] = sum;
 
     std::string hex;
@@ -117,7 +118,7 @@
     hex.resize(hex.length() + 20,'0');
     std::cout << "hex in: " << hex << std::endl;    
     
-    std::map<std::string, std::vector<dccl::MessageVal> > out;
+    std::map<std::string, std::vector<acomms::DCCLMessageVal> > out;
     
     dccl.decode(4, hex, out);
     
@@ -129,7 +130,7 @@
     i[0] = int(i[0]) + 1;
     i[1] = int(i[1]) + 1;
     
-    dccl::MessageVal tmp = b;
+    acomms::DCCLMessageVal tmp = b;
     invert(tmp);
     b = tmp;
     

=== modified file 'src/acomms/libdccl/examples/test/test.xml'
--- src/acomms/libdccl/examples/test/test.xml	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/examples/test/test.xml	2010-07-15 12:38:39 +0000
@@ -2,9 +2,9 @@
 <message_set>
   <message>
     <name>TEST</name>
-    <size>256</size>
+    <size>128</size>
     <id>4</id>
-    <repeat>5</repeat>
+    <repeat/>
     <layout>
       <static>
         <name>Stat</name>

=== modified file 'src/acomms/libdccl/examples/two_message/CMakeLists.txt'
--- src/acomms/libdccl/examples/two_message/CMakeLists.txt	2009-12-02 05:18:28 +0000
+++ src/acomms/libdccl/examples/two_message/CMakeLists.txt	2010-07-15 12:38:39 +0000
@@ -1,2 +1,2 @@
 add_executable(two_message two_message.cpp)
-target_link_libraries(two_message dccl)
\ No newline at end of file
+target_link_libraries(two_message goby_dccl)
\ No newline at end of file

=== modified file 'src/acomms/libdccl/examples/two_message/two_message.cpp'
--- src/acomms/libdccl/examples/two_message/two_message.cpp	2010-03-22 02:52:39 +0000
+++ src/acomms/libdccl/examples/two_message/two_message.cpp	2010-07-15 12:38:39 +0000
@@ -17,11 +17,12 @@
 // encodes/decodes the message given in the pGeneralCodec documentation
 // also includes the simple.xml file to show example of DCCLCodec instantiation
 // with multiple files
-#include "acomms/dccl.h"
+#include "goby/acomms/dccl.h"
 #include <exception>
 #include <iostream>
 
-using dccl::operator<<;
+using namespace goby;
+using goby::acomms::operator<<;
 
 
 int main()
@@ -33,7 +34,7 @@
     xml_files.insert(DCCL_EXAMPLES_DIR "/dccl_simple/simple.xml");
     xml_files.insert(DCCL_EXAMPLES_DIR "/two_message/two_message.xml");
     
-    dccl::DCCLCodec dccl(xml_files, "../../message_schema.xsd");
+    acomms::DCCLCodec dccl(xml_files, "../../message_schema.xsd");
 
     // show some useful information about all the loaded messages
     std::cout << std::string(30, '#') << std::endl
@@ -75,7 +76,7 @@
               << std::string(30, '#') << std::endl;
 
     // initialize input contents to encoder
-    std::map<std::string, dccl::MessageVal> vals;
+    std::map<std::string, acomms::DCCLMessageVal> vals;
     
     // initialize output hexadecimal
     std::string hex2, hex3;

=== modified file 'src/acomms/libdccl/message.cpp'
--- src/acomms/libdccl/message.cpp	2010-07-11 16:20:55 +0000
+++ src/acomms/libdccl/message.cpp	2010-07-15 12:38:39 +0000
@@ -22,7 +22,7 @@
 
 #include "message.h"
 
-dccl::Message::Message():size_(0),
+goby::acomms::DCCLMessage::DCCLMessage():size_(0),
                          trigger_number_(1), 
                          body_bits_(0),
                          id_(0),
@@ -30,61 +30,64 @@
                          repeat_enabled_(false),
                          repeat_(1)
 {
-    header_.resize(acomms::NUM_HEADER_PARTS);
-    header_[acomms::head_ccl_id] =
-        boost::shared_ptr<MessageVar>(new MessageVarCCLID());
-    header_[acomms::head_dccl_id] =
-        boost::shared_ptr<MessageVar>(new MessageVarDCCLID());
-    header_[acomms::head_time] =
-        boost::shared_ptr<MessageVar>(new MessageVarTime());
-    header_[acomms::head_src_id] =
-        boost::shared_ptr<MessageVar>(new MessageVarSrc());
-    header_[acomms::head_dest_id] =
-        boost::shared_ptr<MessageVar>(new MessageVarDest());
-    header_[acomms::head_multimessage_flag] =
-        boost::shared_ptr<MessageVar>(new MessageVarMultiMessageFlag());
-    header_[acomms::head_broadcast_flag] =
-        boost::shared_ptr<MessageVar>(new MessageVarBroadcastFlag());
-    header_[acomms::head_unused] =
-        boost::shared_ptr<MessageVar>(new MessageVarUnused());
+    header_.resize(DCCL_NUM_HEADER_PARTS);
+    header_[head_ccl_id] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarCCLID());
+    header_[head_dccl_id] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarDCCLID());
+    header_[head_time] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarTime());
+    header_[head_src_id] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarSrc());
+    header_[head_dest_id] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarDest());
+    header_[head_multimessage_flag] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarMultiMessageFlag());
+    header_[head_broadcast_flag] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarBroadcastFlag());
+    header_[head_unused] =
+        boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarUnused());
 }
 
     
 // add a new message_var to the current messages vector
-void dccl::Message::add_message_var(const std::string& type)
+void goby::acomms::DCCLMessage::add_message_var(const std::string& type)
 {
     if(type == "static")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarStatic()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarStatic()));
     else if(type == "int")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarInt()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarInt()));
     else if(type == "string")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarString()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarString()));
     else if(type == "float")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarFloat()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarFloat()));
     else if(type == "enum")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarEnum()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarEnum()));
     else if(type == "bool")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarBool()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarBool()));
     else if(type == "hex")
-        layout_.push_back(boost::shared_ptr<MessageVar>(new MessageVarHex()));
+        layout_.push_back(boost::shared_ptr<DCCLMessageVar>(new DCCLMessageVarHex()));
 }
 
 // add a new publish, i.e. a set of parameters to publish
 // upon receipt of an incoming (hex) message
-void dccl::Message::add_publish()
+void goby::acomms::DCCLMessage::add_publish()
 {
-    Publish p;
+    DCCLPublish p;
     publishes_.push_back(p);
 }
 
 // a number of tasks to perform after reading in an entire <message> from
 // the xml file
-void dccl::Message::preprocess()
+void goby::acomms::DCCLMessage::preprocess()
 {
+    if(requested_bytes_total() <= bytes_head())
+        throw(std::runtime_error(std::string("<size> must be larger than the header size of " + boost::lexical_cast<std::string>(bytes_head()))));
+
     // calculate number of repeated messages that will fit and put this in `repeat_`.
     if(repeat_enabled_)
     {
-        BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, layout_)
+        BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, layout_)
         {
         if(mv->array_length() != 1)
             throw(std::runtime_error("<repeat> is not allowed on messages with arrays (<array_length> not 1)"));
@@ -105,7 +108,7 @@
     body_bits_ = calc_total_size();
 
     // initialize header vars
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, header_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, header_)
         mv->initialize(trigger_var_);
 
     
@@ -115,7 +118,7 @@
     }
 
     // iterate over publishes_
-    BOOST_FOREACH(Publish& p, publishes_)
+    BOOST_FOREACH(DCCLPublish& p, publishes_)
         p.initialize(*this);
     
     // set incoming_var / outgoing_var if not set
@@ -125,18 +128,18 @@
         out_var_ = "OUT_" + boost::to_upper_copy(name_) + "_HEX_" + boost::lexical_cast<std::string>(size_) + "B";   
 }
 
-void dccl::Message::set_repeat_array_length()
+void goby::acomms::DCCLMessage::set_repeat_array_length()
 {
-    // set array_length_ for repeated messages for all MessageVars
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, layout_)
+    // set array_length_ for repeated messages for all DCCLMessageVars
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, layout_)
         mv->set_array_length(repeat_);
 }
 
-unsigned dccl::Message::calc_total_size()
+unsigned goby::acomms::DCCLMessage::calc_total_size()
 {
     unsigned body_bits = 0;
     // iterate over layout_
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, layout_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, layout_)
     {
         mv->initialize(trigger_var_);
         // calculate total bits for the message from the bits for each message_var
@@ -147,15 +150,15 @@
 
 
 
-std::map<std::string, std::string> dccl::Message::message_var_names() const
+std::map<std::string, std::string> goby::acomms::DCCLMessage::message_var_names() const
 {
     std::map<std::string, std::string> s;
-    BOOST_FOREACH(const boost::shared_ptr<MessageVar> mv, layout_)
+    BOOST_FOREACH(const boost::shared_ptr<DCCLMessageVar> mv, layout_)
         s.insert(std::pair<std::string, std::string>(mv->name(), type_to_string(mv->type())));
     return s;
 }
 
-std::set<std::string> dccl::Message::get_pubsub_encode_vars()
+std::set<std::string> goby::acomms::DCCLMessage::get_pubsub_encode_vars()
 {
     std::set<std::string> s = get_pubsub_src_vars();
     if(trigger_type_ == "publish")
@@ -163,14 +166,14 @@
     return s;
 }
 
-std::set<std::string> dccl::Message::get_pubsub_decode_vars()
+std::set<std::string> goby::acomms::DCCLMessage::get_pubsub_decode_vars()
 {
     std::set<std::string> s;
     s.insert(in_var_);
     return s;
 }
     
-std::set<std::string> dccl::Message::get_pubsub_all_vars()
+std::set<std::string> goby::acomms::DCCLMessage::get_pubsub_all_vars()
 {
     std::set<std::string> s_enc = get_pubsub_encode_vars();
     std::set<std::string> s_dec = get_pubsub_decode_vars();
@@ -181,25 +184,25 @@
     return s;
 }
     
-std::set<std::string> dccl::Message::get_pubsub_src_vars()
+std::set<std::string> goby::acomms::DCCLMessage::get_pubsub_src_vars()
 {
     std::set<std::string> s;
 
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, layout_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, layout_)
         s.insert(mv->source_var());
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, header_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, header_)
         s.insert(mv->source_var());
     
     return s;
 }
 
     
-void dccl::Message::body_encode(std::string& body, std::map<std::string, std::vector<MessageVal> >& in)
+void goby::acomms::DCCLMessage::body_encode(std::string& body, std::map<std::string, std::vector<DCCLMessageVal> >& in)
 {
     boost::dynamic_bitset<unsigned char> body_bits(bytes2bits(used_bytes_body()));
 
     // 1. encode each variable into the bitset
-    for (std::vector< boost::shared_ptr<MessageVar> >::iterator it = layout_.begin(),
+    for (std::vector< boost::shared_ptr<DCCLMessageVar> >::iterator it = layout_.begin(),
              n = layout_.end();
          it != n;
          ++it)
@@ -214,7 +217,7 @@
     body.resize(body.find_last_not_of(char(0))+1);
 }
 
-void dccl::Message::body_decode(std::string& body, std::map<std::string, std::vector<MessageVal> >& out)
+void goby::acomms::DCCLMessage::body_decode(std::string& body, std::map<std::string, std::vector<DCCLMessageVal> >& out)
 {
     boost::dynamic_bitset<unsigned char> body_bits(bytes2bits(used_bytes_body()));       
     
@@ -225,7 +228,7 @@
     string2bitset(body_bits, body);
     
     // 1. pull the bits off the message in the reverse that they were put on
-    for (std::vector< boost::shared_ptr<MessageVar> >::reverse_iterator it = layout_.rbegin(),
+    for (std::vector< boost::shared_ptr<DCCLMessageVar> >::reverse_iterator it = layout_.rbegin(),
              n = layout_.rend();
          it != n;
          ++it)
@@ -234,9 +237,9 @@
     }
 }
 
-void dccl::Message::set_head_defaults(std::map<std::string, std::vector<MessageVal> >& in, unsigned modem_id)
+void goby::acomms::DCCLMessage::set_head_defaults(std::map<std::string, std::vector<DCCLMessageVal> >& in, unsigned modem_id)
 {
-    for (std::vector< boost::shared_ptr<MessageVar> >::iterator it = header_.begin(),
+    for (std::vector< boost::shared_ptr<DCCLMessageVar> >::iterator it = header_.begin(),
              n = header_.end();
          it != n;
          ++it)
@@ -245,12 +248,12 @@
     }
 }
 
-void dccl::Message::head_encode(std::string& head, std::map<std::string, std::vector<MessageVal> >& in)
+void goby::acomms::DCCLMessage::head_encode(std::string& head, std::map<std::string, std::vector<DCCLMessageVal> >& in)
 {    
-    boost::dynamic_bitset<unsigned char> head_bits(bytes2bits(acomms::NUM_HEADER_BYTES));
+    boost::dynamic_bitset<unsigned char> head_bits(bytes2bits(DCCL_NUM_HEADER_BYTES));
 
     
-    for (std::vector< boost::shared_ptr<MessageVar> >::iterator it = header_.begin(),
+    for (std::vector< boost::shared_ptr<DCCLMessageVar> >::iterator it = header_.begin(),
              n = header_.end();
          it != n;
          ++it)
@@ -261,12 +264,12 @@
     bitset2string(head_bits, head);
 }
 
-void dccl::Message::head_decode(const std::string& head, std::map<std::string, std::vector<MessageVal> >& out)
+void goby::acomms::DCCLMessage::head_decode(const std::string& head, std::map<std::string, std::vector<DCCLMessageVal> >& out)
 {
-    boost::dynamic_bitset<unsigned char> head_bits(bytes2bits(acomms::NUM_HEADER_BYTES));
+    boost::dynamic_bitset<unsigned char> head_bits(bytes2bits(DCCL_NUM_HEADER_BYTES));
     string2bitset(head_bits, head);
 
-    for (std::vector< boost::shared_ptr<MessageVar> >::reverse_iterator it = header_.rbegin(), n = header_.rend();
+    for (std::vector< boost::shared_ptr<DCCLMessageVar> >::reverse_iterator it = header_.rbegin(), n = header_.rend();
          it != n;
          ++it)
     {
@@ -274,20 +277,20 @@
     }
 }
 
-boost::shared_ptr<dccl::MessageVar> dccl::Message::name2message_var(const std::string& name)
+boost::shared_ptr<goby::acomms::DCCLMessageVar> goby::acomms::DCCLMessage::name2message_var(const std::string& name)
 {
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, layout_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, layout_)
     {
         if(mv->name() == name) return mv;
     }    
-    BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, header_)
+    BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, header_)
     {
         if(mv->name() == name) return mv;
     }
 
     throw std::runtime_error(std::string("DCCL: no such name \"" + name + "\" found in <layout> or <header>"));
     
-    return boost::shared_ptr<dccl::MessageVar>();
+    return boost::shared_ptr<DCCLMessageVar>();
 }
 
 ////////////////////////////
@@ -295,8 +298,8 @@
 ////////////////////////////
 
     
-// a long visual display of all the parameters for a Message
-std::string dccl::Message::get_display() const
+// a long visual display of all the parameters for a DCCLMessage
+std::string goby::acomms::DCCLMessage::get_display() const
 {
     const unsigned int num_stars = 20;
 
@@ -335,12 +338,12 @@
     ss << "actual size {bytes} [bits]: {" << used_bytes_total() << "} [" << used_bits_total() << "]" << std::endl;
 
     ss << ">>>> HEADER <<<<" << std::endl;
-    BOOST_FOREACH(const boost::shared_ptr<MessageVar> mv, header_)
+    BOOST_FOREACH(const boost::shared_ptr<DCCLMessageVar> mv, header_)
         ss << *mv;
     
     ss << ">>>> LAYOUT (message_vars) <<<<" << std::endl;
 
-    BOOST_FOREACH(const boost::shared_ptr<MessageVar> mv, layout_)
+    BOOST_FOREACH(const boost::shared_ptr<DCCLMessageVar> mv, layout_)
         ss << *mv;
     
     if(is_moos)
@@ -348,7 +351,7 @@
 
         ss << ">>>> PUBLISHES <<<<" << std::endl;
         
-        BOOST_FOREACH(const Publish& p, publishes_)
+        BOOST_FOREACH(const DCCLPublish& p, publishes_)
             ss << p;
     }
     
@@ -359,7 +362,7 @@
 }
 
 // a much shorter rundown of the Message parameters
-std::string dccl::Message::get_short_display() const
+std::string goby::acomms::DCCLMessage::get_short_display() const
 {
     std::stringstream ss;
 
@@ -384,7 +387,7 @@
 }
     
 // overloaded <<
-std::ostream& dccl::operator<< (std::ostream& out, const Message& message)
+std::ostream& goby::acomms::operator<< (std::ostream& out, const DCCLMessage& message)
 {
     out << message.get_display();
     return out;

=== modified file 'src/acomms/libdccl/message.h'
--- src/acomms/libdccl/message.h	2010-07-11 16:20:55 +0000
+++ src/acomms/libdccl/message.h	2010-07-15 12:38:39 +0000
@@ -31,8 +31,7 @@
 #include <boost/foreach.hpp>
 #include <boost/shared_ptr.hpp>
 
-#include "util/tes_utils.h"
-#include "acomms/modem_message.h"
+#include "goby/acomms/modem_message.h"
 
 #include "message_var.h"
 #include "message_var_int.h"
@@ -47,197 +46,200 @@
 #include "message_publish.h"
 #include "dccl_constants.h"
 
-namespace dccl
+
+namespace goby
 {
-    
-// the Message itself
-    class Message 
-    {
-      public:
-        Message();
-        
-        // set
-        void set_name(const std::string& name) {name_ = name;}
-
-        void set_id(unsigned id)
-        { id_ = id; }
-        template<typename T> void set_id(const T& t)
-        { set_id(boost::lexical_cast<unsigned>(t)); }
-        
-        void set_trigger(const std::string& trigger_type) 
-        { trigger_type_ = trigger_type; }
-        
-        void set_trigger_var(const std::string& trigger_var)
-        { trigger_var_ = trigger_var; }
-
-        void set_trigger_time(double trigger_time)
-        { trigger_time_ = trigger_time; }
-        template<typename T> void set_trigger_time(const T& t)
-        { set_trigger_time(boost::lexical_cast<double>(t)); }        
-        
-        void set_trigger_mandatory(const std::string& trigger_mandatory)
-        { trigger_mandatory_ = trigger_mandatory; }
-    
-        void set_in_var(const std::string& in_var)
-        { in_var_ = in_var; }
-
-        void set_out_var(const std::string& out_var)
-        { out_var_ = out_var; }
-
-        void set_size(unsigned size)
-        { size_ = size; }
-
-        template<typename T> void set_size(const T& t)
-        { set_size(boost::lexical_cast<unsigned>(t)); }
-
-        void set_repeat_enabled(unsigned repeat_enabled)
-        { repeat_enabled_ = repeat_enabled; }
-        template<typename T> void set_repeat_enabled(const T& t)
-        { set_repeat_enabled(boost::lexical_cast<unsigned>(t)); }
-        
-        void add_message_var(const std::string& type);        
-        void add_publish();
-
-        //get
-        std::string name() const              { return name_; }
-        unsigned id() const                   { return id_; }
-        std::string trigger_var() const       { return trigger_var_; }
-        std::string trigger_mandatory() const { return trigger_mandatory_; }
-        double trigger_time() const           { return trigger_time_; }
-        unsigned trigger_number() const       { return trigger_number_; }
-        std::string trigger_type() const      { return trigger_type_; }
-        std::string in_var() const            { return in_var_; }
-        std::string out_var() const           { return out_var_; }
-        bool repeat_enabled() const       { return repeat_enabled_; }
-        unsigned repeat() const               { return repeat_; }
-
-        MessageVar& last_message_var()        { return *layout_.back(); }
-        MessageVar& header_var(acomms::DCCLHeaderPart p) { return *header_[p]; }
-        Publish& last_publish()               { return publishes_.back(); }        
-        
-        std::vector< boost::shared_ptr<MessageVar> >& layout()     { return layout_; }
-        std::vector< boost::shared_ptr<MessageVar> >& header()     { return header_; }
-        std::vector<Publish>& publishes()                      { return publishes_; }
-
-        std::set<std::string> get_pubsub_encode_vars();
-        std::set<std::string> get_pubsub_decode_vars();
-        std::set<std::string> get_pubsub_src_vars();
-        std::set<std::string> get_pubsub_all_vars();
-
-        boost::shared_ptr<MessageVar> name2message_var(const std::string& name);
-        
-        
-        //other
-        std::string get_display() const;
-        std::string get_short_display() const;
-        std::map<std::string, std::string> message_var_names() const;
-        void preprocess();
-        void set_repeat_array_length();
-        unsigned calc_total_size();
-        
-        void set_head_defaults(std::map<std::string, std::vector<MessageVal> >& in, unsigned modem_id);
-        
-    
-        void head_encode(std::string& head, std::map<std::string, std::vector<MessageVal> >& in);
-        void head_decode(const std::string& head, std::map<std::string, std::vector<MessageVal> >& out);
-        
-        void body_encode(std::string& body, std::map<std::string, std::vector<MessageVal> >& in);
-        void body_decode(std::string& body, std::map<std::string, std::vector<MessageVal> >& out);
-
-        // increment, means increase trigger number
-        // prefix ++Message
-        Message& operator++()
-        { ++trigger_number_; return(*this); }
-        // postfix Message++
-        const Message operator++(int)
-        { Message tmp(*this); ++(*this); return tmp;}
-        
-        
-      private:
-        unsigned bytes_head() const
-        { return acomms::NUM_HEADER_BYTES; }
-        unsigned bits_head() const
-        { return bytes2bits(acomms::NUM_HEADER_BYTES); }
-
-        // more efficient way to do ceil(total_bits / 8)
-        // to get the number of bytes rounded up.
-        
-        enum { BYTE_MASK = 7 }; // 00000111
-        unsigned used_bytes_body() const
-        {
-            return (body_bits_& BYTE_MASK) ?
-                bits2bytes(body_bits_) + 1 :
-                bits2bytes(body_bits_);
-        }
-
-        unsigned used_bytes_total() const
-        { return bytes_head() + used_bytes_body(); }
-
-        unsigned used_bits_body() const
-        { return body_bits_; }
-        
-        unsigned used_bits_total() const
-        { return bits_head() + used_bits_body(); }
-        
-        unsigned requested_bytes_body() const
-        { return size_ - acomms::NUM_HEADER_BYTES; }
-
-        unsigned requested_bytes_total() const
-        { return size_; }
-
-        unsigned requested_bits_body() const
-        { return bytes2bits(size_ - acomms::NUM_HEADER_BYTES); } 
-
-        unsigned requested_bits_total() const
-        { return bytes2bits(size_); }
-        
-        
-      private:
-        // total request size of message, e.g. 32 bytes
-        unsigned size_;
-        
-        unsigned trigger_number_;
-        // actual used bits in body part of message (not including header bits)
-        unsigned body_bits_;
-
-        unsigned id_;
-        unsigned modem_id_;
-        double trigger_time_;        
-
-        bool repeat_enabled_;
-        unsigned repeat_;
-        
-        std::string name_;
-        std::string trigger_type_;
-        std::string trigger_var_;
-        std::string trigger_mandatory_;
-        std::string in_var_;
-        std::string out_var_;
-
-        std::vector< boost::shared_ptr<MessageVar> > layout_;
-        std::vector< boost::shared_ptr<MessageVar> > header_;
-        
-        
-        std::vector<Publish> publishes_;
-
-    };
-
-
-    inline void bitset2string(const boost::dynamic_bitset<unsigned char>& body_bits,
-                              std::string& body)
-    {
-        body.resize(body_bits.num_blocks()); // resize the string to fit the bitset
-        to_block_range(body_bits, body.rbegin());
-    }
-    
-    inline void string2bitset(boost::dynamic_bitset<unsigned char>& body_bits,
-                              const std::string& body)
-    {
-        from_block_range(body.rbegin(), body.rend(), body_bits);
-    }
-
-
-    std::ostream& operator<< (std::ostream& out, const Message& message);
+    namespace acomms
+    {
+    
+// the DCCLMessage itself
+        class DCCLMessage 
+        {
+          public:
+            DCCLMessage();
+        
+            // set
+            void set_name(const std::string& name) {name_ = name;}
+
+            void set_id(unsigned id)
+            { id_ = id; }
+            template<typename T> void set_id(const T& t)
+            { set_id(boost::lexical_cast<unsigned>(t)); }
+        
+            void set_trigger(const std::string& trigger_type) 
+            { trigger_type_ = trigger_type; }
+        
+            void set_trigger_var(const std::string& trigger_var)
+            { trigger_var_ = trigger_var; }
+
+            void set_trigger_time(double trigger_time)
+            { trigger_time_ = trigger_time; }
+            template<typename T> void set_trigger_time(const T& t)
+            { set_trigger_time(boost::lexical_cast<double>(t)); }        
+        
+            void set_trigger_mandatory(const std::string& trigger_mandatory)
+            { trigger_mandatory_ = trigger_mandatory; }
+    
+            void set_in_var(const std::string& in_var)
+            { in_var_ = in_var; }
+
+            void set_out_var(const std::string& out_var)
+            { out_var_ = out_var; }
+
+            void set_size(unsigned size)
+            { size_ = size; }
+
+            template<typename T> void set_size(const T& t)
+            { set_size(boost::lexical_cast<unsigned>(t)); }
+
+            void set_repeat_enabled(unsigned repeat_enabled)
+            { repeat_enabled_ = repeat_enabled; }
+            template<typename T> void set_repeat_enabled(const T& t)
+            { set_repeat_enabled(boost::lexical_cast<unsigned>(t)); }
+        
+            void add_message_var(const std::string& type);        
+            void add_publish();
+
+            //get
+            std::string name() const              { return name_; }
+            unsigned id() const                   { return id_; }
+            std::string trigger_var() const       { return trigger_var_; }
+            std::string trigger_mandatory() const { return trigger_mandatory_; }
+            double trigger_time() const           { return trigger_time_; }
+            unsigned trigger_number() const       { return trigger_number_; }
+            std::string trigger_type() const      { return trigger_type_; }
+            std::string in_var() const            { return in_var_; }
+            std::string out_var() const           { return out_var_; }
+            bool repeat_enabled() const       { return repeat_enabled_; }
+            unsigned repeat() const               { return repeat_; }
+
+            DCCLMessageVar& last_message_var()        { return *layout_.back(); }
+            DCCLMessageVar& header_var(acomms::DCCLHeaderPart p) { return *header_[p]; }
+            DCCLPublish& last_publish()               { return publishes_.back(); }        
+        
+            std::vector< boost::shared_ptr<DCCLMessageVar> >& layout()     { return layout_; }
+            std::vector< boost::shared_ptr<DCCLMessageVar> >& header()     { return header_; }
+            std::vector<DCCLPublish>& publishes()                      { return publishes_; }
+
+            std::set<std::string> get_pubsub_encode_vars();
+            std::set<std::string> get_pubsub_decode_vars();
+            std::set<std::string> get_pubsub_src_vars();
+            std::set<std::string> get_pubsub_all_vars();
+
+            boost::shared_ptr<DCCLMessageVar> name2message_var(const std::string& name);
+        
+        
+            //other
+            std::string get_display() const;
+            std::string get_short_display() const;
+            std::map<std::string, std::string> message_var_names() const;
+            void preprocess();
+            void set_repeat_array_length();
+            unsigned calc_total_size();
+        
+            void set_head_defaults(std::map<std::string, std::vector<DCCLMessageVal> >& in, unsigned modem_id);
+        
+    
+            void head_encode(std::string& head, std::map<std::string, std::vector<DCCLMessageVal> >& in);
+            void head_decode(const std::string& head, std::map<std::string, std::vector<DCCLMessageVal> >& out);
+        
+            void body_encode(std::string& body, std::map<std::string, std::vector<DCCLMessageVal> >& in);
+            void body_decode(std::string& body, std::map<std::string, std::vector<DCCLMessageVal> >& out);
+
+            // increment, means increase trigger number
+            // prefix ++DCCLMessage
+            DCCLMessage& operator++()
+            { ++trigger_number_; return(*this); }
+            // postfix DCCLMessage++
+            const DCCLMessage operator++(int)
+            { DCCLMessage tmp(*this); ++(*this); return tmp;}
+        
+        
+          private:
+            unsigned bytes_head() const
+            { return acomms::DCCL_NUM_HEADER_BYTES; }
+            unsigned bits_head() const
+            { return bytes2bits(acomms::DCCL_NUM_HEADER_BYTES); }
+
+            // more efficient way to do ceil(total_bits / 8)
+            // to get the number of bytes rounded up.
+        
+            enum { BYTE_MASK = 7 }; // 00000111
+            unsigned used_bytes_body() const
+            {
+                return (body_bits_& BYTE_MASK) ?
+                    bits2bytes(body_bits_) + 1 :
+                    bits2bytes(body_bits_);
+            }
+
+            unsigned used_bytes_total() const
+            { return bytes_head() + used_bytes_body(); }
+
+            unsigned used_bits_body() const
+            { return body_bits_; }
+        
+            unsigned used_bits_total() const
+            { return bits_head() + used_bits_body(); }
+        
+            unsigned requested_bytes_body() const
+            { return size_ - acomms::DCCL_NUM_HEADER_BYTES; }
+
+            unsigned requested_bytes_total() const
+            { return size_; }
+
+            unsigned requested_bits_body() const
+            { return bytes2bits(size_ - acomms::DCCL_NUM_HEADER_BYTES); } 
+
+            unsigned requested_bits_total() const
+            { return bytes2bits(size_); }
+        
+        
+          private:
+            // total request size of message, e.g. 32 bytes
+            unsigned size_;
+        
+            unsigned trigger_number_;
+            // actual used bits in body part of message (not including header bits)
+            unsigned body_bits_;
+
+            unsigned id_;
+            unsigned modem_id_;
+            double trigger_time_;        
+
+            bool repeat_enabled_;
+            unsigned repeat_;
+        
+            std::string name_;
+            std::string trigger_type_;
+            std::string trigger_var_;
+            std::string trigger_mandatory_;
+            std::string in_var_;
+            std::string out_var_;
+
+            std::vector< boost::shared_ptr<DCCLMessageVar> > layout_;
+            std::vector< boost::shared_ptr<DCCLMessageVar> > header_;
+        
+        
+            std::vector<DCCLPublish> publishes_;
+
+        };
+
+
+        inline void bitset2string(const boost::dynamic_bitset<unsigned char>& body_bits,
+                                  std::string& body)
+        {
+            body.resize(body_bits.num_blocks()); // resize the string to fit the bitset
+            to_block_range(body_bits, body.rbegin());
+        }
+    
+        inline void string2bitset(boost::dynamic_bitset<unsigned char>& body_bits,
+                                  const std::string& body)
+        {
+            from_block_range(body.rbegin(), body.rend(), body_bits);
+        }
+
+
+        std::ostream& operator<< (std::ostream& out, const DCCLMessage& message);
+    }
 }
-
 #endif

=== modified file 'src/acomms/libdccl/message_algorithms.cpp'
--- src/acomms/libdccl/message_algorithms.cpp	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_algorithms.cpp	2010-07-15 12:38:39 +0000
@@ -22,33 +22,34 @@
 #include "message_algorithms.h"
 #include "message_val.h"
 
-dccl::AlgorithmPerformer* dccl::AlgorithmPerformer::inst_ = NULL;
+#include "goby/util/string.h"
+
+goby::acomms::DCCLAlgorithmPerformer* goby::acomms::DCCLAlgorithmPerformer::inst_ = 0;
 
 // singleton class, use this to get pointer
-dccl::AlgorithmPerformer* dccl::AlgorithmPerformer::getInstance()
+goby::acomms::DCCLAlgorithmPerformer* goby::acomms::DCCLAlgorithmPerformer::getInstance()
 {
-    if(inst_ == NULL)
-        inst_ = new AlgorithmPerformer();
+    if(!inst_) inst_ = new DCCLAlgorithmPerformer();
 
     return(inst_);
 }
 
-void dccl::AlgorithmPerformer::algorithm(MessageVal& in, unsigned array_index, const std::string& algorithm, const std::map<std::string,std::vector<MessageVal> >& vals)
+void goby::acomms::DCCLAlgorithmPerformer::algorithm(DCCLMessageVal& in, unsigned array_index, const std::string& algorithm, const std::map<std::string,std::vector<DCCLMessageVal> >& vals)
 {
     if(in.empty()) return;
 
 // algo_name:ref_variable_name1:ref_variable_name2...
     
-    std::vector<std::string>ref_vars = tes_util::explode(algorithm, ':', true);
+    std::vector<std::string>ref_vars = util::explode(algorithm, ':', true);
 
     std::string alg;
-    std::vector<MessageVal> tied_vals;
+    std::vector<DCCLMessageVal> tied_vals;
 
     for(std::vector<std::string>::size_type i = 1, n = ref_vars.size();
         i < n;
         ++i)
     {
-        std::map<std::string, std::vector<dccl::MessageVal> >::const_iterator it = vals.find(ref_vars[i]);
+        std::map<std::string, std::vector<DCCLMessageVal> >::const_iterator it = vals.find(ref_vars[i]);
         if(it != vals.end() && array_index < it->second.size())
             tied_vals.push_back(it->second[array_index]);
         else

=== modified file 'src/acomms/libdccl/message_algorithms.h'
--- src/acomms/libdccl/message_algorithms.h	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_algorithms.h	2010-07-15 12:38:39 +0000
@@ -28,45 +28,46 @@
 
 #include <boost/algorithm/string.hpp>
 #include <boost/function.hpp>
-
-namespace dccl
+namespace goby
 {
-    class MessageVal;
+    namespace acomms
+    {
+        class DCCLMessageVal;
     
-    /// \brief boost::function for a function taking a single dccl::MessageVal reference. Used for algorithm callbacks.
-    ///
-    /// Think of this as a generalized version of a function pointer (void (*)(dccl::MessageVal&)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
-    typedef boost::function<void (MessageVal&)> AlgFunction1;
-    /// \brief boost::function for a function taking a dccl::MessageVal reference, and the MessageVal of a second part of the message. Used for algorithm callbacks.
-    ///
-    /// Think of this as a generalized version of a function pointer (void (*)(MessageVal&, const MessageVal&). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
-    typedef boost::function<void (MessageVal&, const std::vector<MessageVal>&)> AlgFunction2;
-
-    class AlgorithmPerformer
-    {
-      public:
-        static AlgorithmPerformer* getInstance();
-
-        void algorithm(MessageVal& in, unsigned array_index, const std::string& algorithm, const std::map<std::string,std::vector<MessageVal> >& vals);
-        
-        void add_algorithm(const std::string& name, AlgFunction1 func)
-        { adv_map1_[name] = func; }
-
-        void add_algorithm(const std::string& name, AlgFunction2 func)
-        { adv_map2_[name] = func; }
-        
-      private:
-        static AlgorithmPerformer* inst_;
-        std::map<std::string, AlgFunction1> adv_map1_;
-        std::map<std::string, AlgFunction2> adv_map2_;
-        
-        AlgorithmPerformer()
-        {}
-        
-        AlgorithmPerformer(const AlgorithmPerformer&);
-        AlgorithmPerformer& operator = (const AlgorithmPerformer&);
+        /// \brief boost::function for a function taking a single DCCLMessageVal reference. Used for algorithm callbacks.
+        ///
+        /// Think of this as a generalized version of a function pointer (void (*)(DCCLMessageVal&)). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
+        typedef boost::function<void (DCCLMessageVal&)> AlgFunction1;
+        /// \brief boost::function for a function taking a dccl::MessageVal reference, and the MessageVal of a second part of the message. Used for algorithm callbacks.
+        ///
+        /// Think of this as a generalized version of a function pointer (void (*)(DCCLMessageVal&, const DCCLMessageVal&). See http://www.boost.org/doc/libs/1_34_0/doc/html/function.html for more on boost:function.
+        typedef boost::function<void (DCCLMessageVal&, const std::vector<DCCLMessageVal>&)> AlgFunction2;
+
+        class DCCLAlgorithmPerformer
+        {
+          public:
+            static DCCLAlgorithmPerformer* getInstance();
+
+            void algorithm(DCCLMessageVal& in, unsigned array_index, const std::string& algorithm, const std::map<std::string,std::vector<DCCLMessageVal> >& vals);
+        
+            void add_algorithm(const std::string& name, AlgFunction1 func)
+            { adv_map1_[name] = func; }
+
+            void add_algorithm(const std::string& name, AlgFunction2 func)
+            { adv_map2_[name] = func; }
+        
+          private:
+            static DCCLAlgorithmPerformer* inst_;
+            std::map<std::string, AlgFunction1> adv_map1_;
+            std::map<std::string, AlgFunction2> adv_map2_;
+        
+            DCCLAlgorithmPerformer()
+            {}
+        
+            DCCLAlgorithmPerformer(const DCCLAlgorithmPerformer&);
+            DCCLAlgorithmPerformer& operator = (const DCCLAlgorithmPerformer&);
       
-    };
+        };
+    }
 }
-
 #endif

=== modified file 'src/acomms/libdccl/message_publish.cpp'
--- src/acomms/libdccl/message_publish.cpp	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_publish.cpp	2010-07-15 12:38:39 +0000
@@ -22,9 +22,9 @@
 #include "message_publish.h"
 #include "message.h"
 
-using acomms::NaN;
+using goby::acomms::NaN;
 
-void dccl::Publish::initialize(Message& msg)
+void goby::acomms::DCCLPublish::initialize(DCCLMessage& msg)
 {
     repeat_ = msg.repeat();
 
@@ -36,7 +36,7 @@
     // add names for any <all/> publishes and empty std::vector for algorithms
     if(use_all_names_)
     {
-        BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, msg.header())
+        BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, msg.header())
         {
             // ignore header pieces not explicitly overloaded by the <name> tag
             if(!mv->name().empty() && !(mv->name()[0] == '_'))
@@ -47,7 +47,7 @@
             }
         }
         
-        BOOST_FOREACH(boost::shared_ptr<MessageVar> mv, msg.layout())
+        BOOST_FOREACH(boost::shared_ptr<DCCLMessageVar> mv, msg.layout())
         {
             add_message_var(mv);
             // add an empty std::vector for algorithms (no algorithms allowed for <all/> tag)
@@ -60,7 +60,7 @@
     if(!format_set_)
     {
         std::string format_str;
-        for (std::vector<boost::shared_ptr<MessageVar> >::size_type j = 0, m = message_vars_.size(); j < m; ++j)
+        for (std::vector<boost::shared_ptr<DCCLMessageVar> >::size_type j = 0, m = message_vars_.size(); j < m; ++j)
         {
             if (m > 1)
             {
@@ -102,10 +102,10 @@
 }
 
 
-void dccl::Publish::fill_format(const std::map<std::string,std::vector<MessageVal> >& vals,
-                                std::string& key,
-                                std::string& value,
-                                unsigned repeat_index)
+void goby::acomms::DCCLPublish::fill_format(const std::map<std::string,std::vector<DCCLMessageVal> >& vals,
+                                            std::string& key,
+                                            std::string& value,
+                                            unsigned repeat_index)
 {
     std::string filled_value;
     // format is a boost library class for replacing printf and its ilk
@@ -120,10 +120,10 @@
         f.parse(input_format);
             
         // iterate over the message_vars and fill in the format field
-        for (std::vector<boost::shared_ptr<MessageVar> >::size_type k = 0, o = message_vars_.size(); k < o; ++k)
+        for (std::vector<boost::shared_ptr<DCCLMessageVar> >::size_type k = 0, o = message_vars_.size(); k < o; ++k)
         {
-            std::vector<MessageVal> vm = vals.find(message_vars_[k]->name())->second;
-            for(std::vector<MessageVal>::size_type i = (repeat_ > 1) ? repeat_index : 0,
+            std::vector<DCCLMessageVal> vm = vals.find(message_vars_[k]->name())->second;
+            for(std::vector<DCCLMessageVal>::size_type i = (repeat_ > 1) ? repeat_index : 0,
                     n = (repeat_ > 1) ? repeat_index + 1 : vm.size();
                 i < n;
                 ++i)
@@ -159,8 +159,8 @@
 
     
 
-void dccl::Publish::write_publish(const std::map<std::string,std::vector<MessageVal> >& vals,
-                                  std::multimap<std::string,MessageVal>& pubsub_vals)
+void goby::acomms::DCCLPublish::write_publish(const std::map<std::string,std::vector<DCCLMessageVal> >& vals,
+                                              std::multimap<std::string,DCCLMessageVal>& pubsub_vals)
 
 {
     for(unsigned i = 0, n = repeat_;
@@ -173,29 +173,29 @@
         // user sets to string
         if(type_ == cpp_string)
         {
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_val));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_val));
             continue;
         }
         
-        // pass through a MessageVal to do the type conversions
-        MessageVal mv = out_val;
+        // pass through a DCCLMessageVal to do the type conversions
+        DCCLMessageVal mv = out_val;
         double out_dval = mv;
         if(type_ == cpp_double)
         {
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_dval));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_dval));
             continue;
         }
         long out_lval = mv;    
         if(type_ == cpp_long)
         {
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_lval));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_lval));
             continue;
             
         }
         bool out_bval = mv;
         if(type_ == cpp_bool)
         {
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_bval));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_bval));
             continue;
         }
         
@@ -205,14 +205,14 @@
         catch (boost::bad_lexical_cast &) { is_numeric = false; }
         
         if(!is_numeric)
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_val));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_val));
         else
-            pubsub_vals.insert(std::pair<std::string, MessageVal>(out_var, out_dval));
+            pubsub_vals.insert(std::pair<std::string, DCCLMessageVal>(out_var, out_dval));
     }
 }
 
     
-std::string dccl::Publish::get_display() const
+std::string goby::acomms::DCCLPublish::get_display() const
 {
     std::stringstream ss;
     
@@ -220,7 +220,7 @@
     ss << ")moos_var: {" << var_ << "}" << std::endl;
     ss << "\tvalue: \"" << format_ << "\"" << std::endl;
     ss << "\tmessage_vars:" << std::endl;
-    for (std::vector<boost::shared_ptr<MessageVar> >::size_type j = 0, m = message_vars_.size(); j < m; ++j)
+    for (std::vector<boost::shared_ptr<DCCLMessageVar> >::size_type j = 0, m = message_vars_.size(); j < m; ++j)
     {
         ss << "\t\t" << (j+1) << ": " << message_vars_[j]->name();
 
@@ -240,7 +240,7 @@
 }
 
 // overloaded <<
-std::ostream& dccl::operator<< (std::ostream& out, const Publish& publish)
+std::ostream& goby::acomms::operator<< (std::ostream& out, const DCCLPublish& publish)
 {
     out << publish.get_display();
     return out;

=== modified file 'src/acomms/libdccl/message_publish.h'
--- src/acomms/libdccl/message_publish.h	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_publish.h	2010-07-15 12:38:39 +0000
@@ -31,77 +31,79 @@
 #include "message_algorithms.h"
 #include "dccl_constants.h"
 
-namespace dccl
+namespace goby
 {
-    class Message;
+    namespace acomms
+    {
+        class DCCLMessage;
     
 // defines (a single) thing to do with the decoded message
 // that is, where do we publish it and what should we include in the
 // published message
-    class Publish
-    {
-      public:
-      Publish() : var_(""),
-            format_(""),
-            format_set_(false),
-            use_all_names_(false),
-            type_(cpp_notype),
-            ap_(AlgorithmPerformer::getInstance()),
-            repeat_(1)
-            { }        
-
-        //set
-    
-        void set_var(std::string var) {var_=var;}
-        void set_format(std::string format) {format_=format; format_set_ = true;}
-        void set_use_all_names(bool use_all_names) {use_all_names_ = use_all_names;}
-        void set_type(DCCLCppType type) {type_ = type;}
-
-        void add_name(const std::string& name) {names_.push_back(name);}
-        void add_message_var(boost::shared_ptr<MessageVar> mv) {message_vars_.push_back(mv);}
-        void add_algorithms(const std::vector<std::string> algorithms) {algorithms_.push_back(algorithms);}
-    
-        //get
+        class DCCLPublish
+        {
+          public:
+          DCCLPublish() : var_(""),
+                format_(""),
+                format_set_(false),
+                use_all_names_(false),
+                type_(cpp_notype),
+                ap_(DCCLAlgorithmPerformer::getInstance()),
+                repeat_(1)
+                { }        
+
+            //set
+    
+            void set_var(std::string var) {var_=var;}
+            void set_format(std::string format) {format_=format; format_set_ = true;}
+            void set_use_all_names(bool use_all_names) {use_all_names_ = use_all_names;}
+            void set_type(DCCLCppType type) {type_ = type;}
+
+            void add_name(const std::string& name) {names_.push_back(name);}
+            void add_message_var(boost::shared_ptr<DCCLMessageVar> mv) {message_vars_.push_back(mv);}
+            void add_algorithms(const std::vector<std::string> algorithms) {algorithms_.push_back(algorithms);}
+    
+            //get
 //    std::string var() const {return var_;}
 //    std::string format() const {return format_;}
 //    bool format_set()  const {return format_set_;}
 //    bool use_all_names() const {return use_all_names_;}
     
-        DCCLCppType type() {return type_;}
+            DCCLCppType type() {return type_;}
 //    std::vector<std::string> const& names() {return names_;}
 //    std::vector<std::vector<std::string> > const& algorithms(){return algorithms_;}
     
         
-        std::string get_display() const;
-
-        void write_publish(const std::map<std::string,std::vector<MessageVal> >& vals,
-                           std::multimap<std::string,MessageVal>& pubsub_vals);
-        
-        
-        
-
-        void initialize(Message& msg);
-
-      private:
-        void fill_format(const std::map<std::string,std::vector<MessageVal> >& vals,
-                         std::string& key,
-                         std::string& value,
-                         unsigned repeat_index);
+            std::string get_display() const;
+
+            void write_publish(const std::map<std::string,std::vector<DCCLMessageVal> >& vals,
+                               std::multimap<std::string,DCCLMessageVal>& pubsub_vals);
+        
+        
+        
+
+            void initialize(DCCLMessage& msg);
+
+          private:
+            void fill_format(const std::map<std::string,std::vector<DCCLMessageVal> >& vals,
+                             std::string& key,
+                             std::string& value,
+                             unsigned repeat_index);
             
-      private:
-        std::string var_;
-        std::string format_;
-        bool format_set_;
-        bool use_all_names_;
-        DCCLCppType type_;
-        std::vector<std::string> names_;
-        std::vector<boost::shared_ptr<MessageVar> > message_vars_;
-        std::vector< std::vector<std::string> > algorithms_;
-        AlgorithmPerformer* ap_;
-        unsigned repeat_;
-    };
+          private:
+            std::string var_;
+            std::string format_;
+            bool format_set_;
+            bool use_all_names_;
+            DCCLCppType type_;
+            std::vector<std::string> names_;
+            std::vector<boost::shared_ptr<DCCLMessageVar> > message_vars_;
+            std::vector< std::vector<std::string> > algorithms_;
+            DCCLAlgorithmPerformer* ap_;
+            unsigned repeat_;
+        };
 
-    std::ostream& operator<< (std::ostream& out, const Publish& publish);
+        std::ostream& operator<< (std::ostream& out, const DCCLPublish& publish);
+    }
 }
-
 #endif

=== modified file 'src/acomms/libdccl/message_val.cpp'
--- src/acomms/libdccl/message_val.cpp	2010-07-13 01:57:57 +0000
+++ src/acomms/libdccl/message_val.cpp	2010-07-15 12:38:39 +0000
@@ -17,13 +17,17 @@
 // You should have received a copy of the GNU General Public License
 // along with this software.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <exception>
+#include <stdexcept>
+#include <iomanip>
 
 #include <boost/foreach.hpp>
 
+#include "goby/util/string.h"
+#include "goby/util/sci.h"
+
 #include "message_val.h"
 
-void dccl::MessageVal::init()
+void goby::acomms::DCCLMessageVal::init()
 {
     sval_ = "";
     dval_ = 0;
@@ -34,27 +38,27 @@
 }
 
 
-dccl::MessageVal::MessageVal()
+goby::acomms::DCCLMessageVal::DCCLMessageVal()
 { init(); }
 
 
-dccl::MessageVal::MessageVal(const std::string& s)
-{
-    init();
-    sval_ = s;
-    type_ = cpp_string;
-}
-
-
-dccl::MessageVal::MessageVal(const char* s)
-{
-    init();
-    sval_ = s;
-    type_ = cpp_string;
-}
-
-
-dccl::MessageVal::MessageVal(double d, int p /* = MAX_DBL_PRECISION*/ )
+goby::acomms::DCCLMessageVal::DCCLMessageVal(const std::string& s)
+{
+    init();
+    sval_ = s;
+    type_ = cpp_string;
+}
+
+
+goby::acomms::DCCLMessageVal::DCCLMessageVal(const char* s)
+{
+    init();
+    sval_ = s;
+    type_ = cpp_string;
+}
+
+
+goby::acomms::DCCLMessageVal::DCCLMessageVal(double d, int p /* = MAX_DBL_PRECISION*/ )
 {
     init();
     dval_ = d;
@@ -62,28 +66,28 @@
     type_ = cpp_double;
 }
 
-dccl::MessageVal::MessageVal(float f)
+goby::acomms::DCCLMessageVal::DCCLMessageVal(float f)
 {
     init();
     dval_ = f;
     type_ = cpp_double;
 }
 
-dccl::MessageVal::MessageVal(long l)
+goby::acomms::DCCLMessageVal::DCCLMessageVal(long l)
 {
     init();
     lval_ = l;
     type_ = cpp_long;
 }        
 
-dccl::MessageVal::MessageVal(int i)
+goby::acomms::DCCLMessageVal::DCCLMessageVal(int i)
 {
     init();
     lval_ = i;
     type_ = cpp_long;
 }        
 
-dccl::MessageVal::MessageVal(bool b)
+goby::acomms::DCCLMessageVal::DCCLMessageVal(bool b)
 {
     init();
     bval_ = b;
@@ -91,26 +95,26 @@
 }        
 
 
-dccl::MessageVal::MessageVal(const std::vector<MessageVal>& vm)
+goby::acomms::DCCLMessageVal::DCCLMessageVal(const std::vector<DCCLMessageVal>& vm)
 {
     if(vm.size() != 1)
-        throw(std::runtime_error("vector cast to MessageVal failed: vector is not size 1"));
+        throw(std::runtime_error("vector cast to DCCLMessageVal failed: vector is not size 1"));
     else
         *this = vm[0];
 }
 
 
-void dccl::MessageVal::set(std::string sval)
+void goby::acomms::DCCLMessageVal::set(std::string sval)
 { sval_ = sval; type_ = cpp_string; }
-void dccl::MessageVal::set(double dval, int precision /* = MAX_DBL_PRECISION */)
+void goby::acomms::DCCLMessageVal::set(double dval, int precision /* = MAX_DBL_PRECISION */)
 { dval_ = dval; type_ = cpp_double; precision_ = precision; }
-void dccl::MessageVal::set(long lval)
+void goby::acomms::DCCLMessageVal::set(long lval)
 { lval_ = lval; type_ = cpp_long; }
-void dccl::MessageVal::set(bool bval)
+void goby::acomms::DCCLMessageVal::set(bool bval)
 { bval_ = bval; type_ = cpp_bool; }
 
 
-bool dccl::MessageVal::get(std::string& s) const
+bool goby::acomms::DCCLMessageVal::get(std::string& s) const
 {
     std::stringstream ss;
     switch(type_)
@@ -141,14 +145,14 @@
     }
 }
 
-bool dccl::MessageVal::get(bool& b) const
+bool goby::acomms::DCCLMessageVal::get(bool& b) const
 {
     switch(type_)
     {
         case cpp_string:
-            if(tes_util::stricmp(sval_, "true") || tes_util::stricmp(sval_, "1"))
+            if(util::stricmp(sval_, "true") || util::stricmp(sval_, "1"))
                 b = true;
-            else if(tes_util::stricmp(sval_, "false") || tes_util::stricmp(sval_, "0"))
+            else if(util::stricmp(sval_, "false") || util::stricmp(sval_, "0"))
                 b = false;
             else
                 return false;
@@ -173,7 +177,7 @@
     }
 }    
 
-bool dccl::MessageVal::get(long& t) const
+bool goby::acomms::DCCLMessageVal::get(long& t) const
 {
     switch(type_)
     {
@@ -181,13 +185,13 @@
             try
             {
                 double d = boost::lexical_cast<double>(sval_);
-                t = boost::numeric_cast<long>(tes_util::sci_round(d, 0));
+                t = boost::numeric_cast<long>(util::unbiased_round(d, 0));
             }
             catch (...)
             {
-                if(tes_util::stricmp(sval_, "true"))
+                if(util::stricmp(sval_, "true"))
                     t = 1;
-                else if(tes_util::stricmp(sval_, "false"))
+                else if(util::stricmp(sval_, "false"))
                     t = 0;
                 else
                     return false;
@@ -195,7 +199,7 @@
             return true;
 
         case cpp_double:
-            try { t = boost::numeric_cast<long>(tes_util::sci_round(dval_, 0)); }
+            try { t = boost::numeric_cast<long>(util::unbiased_round(dval_, 0)); }
             catch(...) { return false; }
             return true;
 
@@ -212,7 +216,7 @@
     }
 }        
         
-bool dccl::MessageVal::get(double& d) const
+bool goby::acomms::DCCLMessageVal::get(double& d) const
 {
     switch(type_)
     {
@@ -220,9 +224,9 @@
             try { d = boost::lexical_cast<double>(sval_); }
             catch (boost::bad_lexical_cast &)
             {
-                if(tes_util::stricmp(sval_, "true"))
+                if(util::stricmp(sval_, "true"))
                     d = 1;
-                else if(tes_util::stricmp(sval_, "false"))
+                else if(util::stricmp(sval_, "false"))
                     d = 0;
                 else
                     return false;
@@ -251,7 +255,7 @@
 
 
 
-dccl::MessageVal::operator double() const
+goby::acomms::DCCLMessageVal::operator double() const
 {
     double d;
     if(get(d)) return d;
@@ -259,48 +263,48 @@
 }
 
 
-dccl::MessageVal::operator bool() const
+goby::acomms::DCCLMessageVal::operator bool() const
 {
     bool b;
     if(get(b)) return b;
     else return false;
 }
 
-dccl::MessageVal::operator std::string() const
+goby::acomms::DCCLMessageVal::operator std::string() const
 {
     std::string s;
     if(get(s)) return s;
     else return "";
 }
 
-dccl::MessageVal::operator long() const
+goby::acomms::DCCLMessageVal::operator long() const
 {
     long l;
     if(get(l)) return l;
     else return 0;
 }
 
-dccl::MessageVal::operator int() const
-{
-    return long(*this);
-}
-
-dccl::MessageVal::operator unsigned() const
-{
-    return long(*this);
-}
-
-dccl::MessageVal::operator float() const
+goby::acomms::DCCLMessageVal::operator int() const
+{
+    return long(*this);
+}
+
+goby::acomms::DCCLMessageVal::operator unsigned() const
+{
+    return long(*this);
+}
+
+goby::acomms::DCCLMessageVal::operator float() const
 {
     return double(*this);
 }
 
-dccl::MessageVal::operator std::vector<MessageVal>() const
+goby::acomms::DCCLMessageVal::operator std::vector<DCCLMessageVal>() const
 {
-    return std::vector<MessageVal>(1, *this);
+    return std::vector<DCCLMessageVal>(1, *this);
 }
 
-bool dccl::MessageVal::operator==(const MessageVal& mv) const
+bool goby::acomms::DCCLMessageVal::operator==(const DCCLMessageVal& mv) const
 {
     switch(mv.type_)
     {
@@ -312,25 +316,25 @@
     }
 }
 
-bool dccl::MessageVal::operator==(const std::string& s)  const
+bool goby::acomms::DCCLMessageVal::operator==(const std::string& s)  const
 {
     std::string us;
     return get(us) && us == s;
 }
 
-bool dccl::MessageVal::operator==(double d) const
+bool goby::acomms::DCCLMessageVal::operator==(double d) const
 {
     double us;
     return get(us) && us == d;
 }
 
-bool dccl::MessageVal::operator==(long l) const
+bool goby::acomms::DCCLMessageVal::operator==(long l) const
 {
     long us;
     return get(us) && us == l;
 }
 
-bool dccl::MessageVal::operator==(bool b) const
+bool goby::acomms::DCCLMessageVal::operator==(bool b) const
 {
     bool us;
     return get(us) && us == b;
@@ -338,7 +342,7 @@
 
 
 
-std::ostream& dccl::operator<<(std::ostream& os, const dccl::MessageVal& mv)
+std::ostream& goby::acomms::operator<<(std::ostream& os, const goby::acomms::DCCLMessageVal& mv)
 {
     switch(mv.type_)
     {
@@ -351,10 +355,10 @@
 }
 
     
-std::ostream& dccl::operator<<(std::ostream& os, const std::vector<dccl::MessageVal>& vm)
+std::ostream& goby::acomms::operator<<(std::ostream& os, const std::vector<goby::acomms::DCCLMessageVal>& vm)
 {
     int j=0;
-    BOOST_FOREACH(const dccl::MessageVal& m, vm)
+    BOOST_FOREACH(const DCCLMessageVal& m, vm)
     {
         if(j) os << ",";
         os << m;

=== modified file 'src/acomms/libdccl/message_val.h'
--- src/acomms/libdccl/message_val.h	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_val.h	2010-07-15 12:38:39 +0000
@@ -25,157 +25,158 @@
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/lexical_cast.hpp> 
 
-#include "util/tes_utils.h"
 #include "dccl_constants.h"
 
-namespace dccl
+namespace goby
 {
+    namespace acomms
+    {
     
 /// defines a DCCL value
-    class MessageVal
-    {
-      public:
-        enum { MAX_DBL_PRECISION = 15 };
-        
-        /// \name Constructors/Destructor
-        //@{         
-        /// empty
-        MessageVal();
-        
-        /// construct with string value
-        MessageVal(const std::string& s);
-        
-        /// construct with char* value
-        MessageVal(const char* s);
-        
-        /// construct with double value, optionally giving the precision of the double (number of decimal places) which is used if a cast to std::string is required in the future.
-        MessageVal(double d, int p = MAX_DBL_PRECISION);
-        
-        /// construct with long value
-        MessageVal(long l);
-        
-        /// construct with int value
-        MessageVal(int i);
-        
-        /// construct with float value
-        MessageVal(float f);
-        
-        /// construct with bool value
-        MessageVal(bool b);
-
-        /// construct with vector
-        MessageVal(const std::vector<MessageVal>& vm);
-
-        
-        
-        //@}
-
-        /// \name Setters
-        //@{  
-        /// set the value with a string (overwrites previous value regardless of type)
-        void set(std::string sval);
-        /// \brief set the value with a double (overwrites previous value regardless of type)
-        /// \param dval values to set
-        /// \param precision decimal places of precision to preserve if this is cast to a string
-        void set(double dval, int precision = MAX_DBL_PRECISION);
-        /// set the value with a long (overwrites previous value regardless of type)
-        void set(long lval);
-        /// set the value with a bool (overwrites previous value regardless of type)
-        void set(bool bval);
-
-       //@}
-        
-        /// \name Getters
-        //@{       
-        /// \brief extract as std::string (all reasonable casts are done)
-        /// \param s std::string to store value in
-        /// \return successfully extracted (and if necessary successfully cast to this type)
-        bool get(std::string& s) const;
-        /// \brief extract as bool (all reasonable casts are done)
-        /// \param b bool to store value in
-        /// \return successfully extracted (and if necessary successfully cast to this type)
-        bool get(bool& b) const;
-        /// \brief extract as long (all reasonable casts are done)
-        /// \param t long to store value in
-        /// \return successfully extracted (and if necessary successfully cast to this type)
-        bool get(long& t) const;        
-        /// \brief extract as double (all reasonable casts are done)
-        /// \param d double to store value in
-        /// \return successfully extracted (and if necessary successfully cast to this type)
-        bool get(double& d) const;
-
-        ///
-        /// allows statements of the form \code double d = MessageVal("3.23"); \endcode
-        operator double() const;
-
-        ///
-        /// allows statements of the form \code bool b = MessageVal("1"); \endcode
-        operator bool() const;
-
-        ///
-        /// allows statements of the form \code std::string s = MessageVal(3); \endcode
-        operator std::string() const;
-
-        ///
-        /// allows statements of the form \code long l = MessageVal(5); \endcode
-        operator long() const;
-
-        ///
-        /// allows statements of the form \code int i = MessageVal(2); \endcode
-        operator int() const;
-
-        ///
-        /// allows statements of the form \code unsigned u = MessageVal(2); \endcode
-        operator unsigned() const;
-
-        ///
-        /// allows statements of the form \code float f = MessageVal("3.5"); \endcode
-        operator float() const;
-
-        operator std::vector<MessageVal>() const;
-        
-
-        /// what type is the original type of this MessageVal?
-        DCCLCppType type() const { return type_; }
-        
-        /// was this just constructed with MessageVal() ? 
-        bool empty() const { return type_ == cpp_notype; }        
-
-        unsigned precision() const { return precision_; }
+        class DCCLMessageVal
+        {
+          public:
+            enum { MAX_DBL_PRECISION = 15 };
+        
+            /// \name Constructors/Destructor
+            //@{         
+            /// empty
+            DCCLMessageVal();
+        
+            /// construct with string value
+            DCCLMessageVal(const std::string& s);
+        
+            /// construct with char* value
+            DCCLMessageVal(const char* s);
+        
+            /// construct with double value, optionally giving the precision of the double (number of decimal places) which is used if a cast to std::string is required in the future.
+            DCCLMessageVal(double d, int p = MAX_DBL_PRECISION);
+        
+            /// construct with long value
+            DCCLMessageVal(long l);
+        
+            /// construct with int value
+            DCCLMessageVal(int i);
+        
+            /// construct with float value
+            DCCLMessageVal(float f);
+        
+            /// construct with bool value
+            DCCLMessageVal(bool b);
+
+            /// construct with vector
+            DCCLMessageVal(const std::vector<DCCLMessageVal>& vm);
+
+        
+        
+            //@}
+
+            /// \name Setters
+            //@{  
+            /// set the value with a string (overwrites previous value regardless of type)
+            void set(std::string sval);
+            /// \brief set the value with a double (overwrites previous value regardless of type)
+            /// \param dval values to set
+            /// \param precision decimal places of precision to preserve if this is cast to a string
+            void set(double dval, int precision = MAX_DBL_PRECISION);
+            /// set the value with a long (overwrites previous value regardless of type)
+            void set(long lval);
+            /// set the value with a bool (overwrites previous value regardless of type)
+            void set(bool bval);
+
+            //@}
+        
+            /// \name Getters
+            //@{       
+            /// \brief extract as std::string (all reasonable casts are done)
+            /// \param s std::string to store value in
+            /// \return successfully extracted (and if necessary successfully cast to this type)
+            bool get(std::string& s) const;
+            /// \brief extract as bool (all reasonable casts are done)
+            /// \param b bool to store value in
+            /// \return successfully extracted (and if necessary successfully cast to this type)
+            bool get(bool& b) const;
+            /// \brief extract as long (all reasonable casts are done)
+            /// \param t long to store value in
+            /// \return successfully extracted (and if necessary successfully cast to this type)
+            bool get(long& t) const;        
+            /// \brief extract as double (all reasonable casts are done)
+            /// \param d double to store value in
+            /// \return successfully extracted (and if necessary successfully cast to this type)
+            bool get(double& d) const;
+
+            ///
+            /// allows statements of the form \code double d = DCCLMessageVal("3.23"); \endcode
+            operator double() const;
+
+            ///
+            /// allows statements of the form \code bool b = DCCLMessageVal("1"); \endcode
+            operator bool() const;
+
+            ///
+            /// allows statements of the form \code std::string s = DCCLMessageVal(3); \endcode
+            operator std::string() const;
+
+            ///
+            /// allows statements of the form \code long l = DCCLMessageVal(5); \endcode
+            operator long() const;
+
+            ///
+            /// allows statements of the form \code int i = DCCLMessageVal(2); \endcode
+            operator int() const;
+
+            ///
+            /// allows statements of the form \code unsigned u = DCCLMessageVal(2); \endcode
+            operator unsigned() const;
+
+            ///
+            /// allows statements of the form \code float f = DCCLMessageVal("3.5"); \endcode
+            operator float() const;
+
+            operator std::vector<DCCLMessageVal>() const;
+        
+
+            /// what type is the original type of this DCCLMessageVal?
+            DCCLCppType type() const { return type_; }
+        
+            /// was this just constructed with DCCLMessageVal() ? 
+            bool empty() const { return type_ == cpp_notype; }        
+
+            unsigned precision() const { return precision_; }
         
 //@}
 
 
-        /// \name Comparison
-        //@{       
-        bool operator==(const MessageVal& mv) const;
-        bool operator==(const std::string& s) const;  
-        bool operator==(double d) const;
-        bool operator==(long l) const;
-        bool operator==(bool b) const;
-        
-        // @}
-        
-      private:
-        void init();
-        
-        friend std::ostream& operator<<(std::ostream& os, const MessageVal& mv);
-        
-      private:
-        std::string sval_;
-        double dval_;
-        long lval_;
-        bool bval_;
-
-        unsigned precision_;
-
-        DCCLCppType type_;
-    };
-
-    std::ostream& operator<<(std::ostream& os, const dccl::MessageVal& mv);
-    std::ostream& operator<<(std::ostream& os, const std::vector<dccl::MessageVal>& vm);
+            /// \name Comparison
+            //@{       
+            bool operator==(const DCCLMessageVal& mv) const;
+            bool operator==(const std::string& s) const;  
+            bool operator==(double d) const;
+            bool operator==(long l) const;
+            bool operator==(bool b) const;
+        
+            // @}
+        
+          private:
+            void init();
+        
+            friend std::ostream& operator<<(std::ostream& os, const DCCLMessageVal& mv);
+        
+          private:
+            std::string sval_;
+            double dval_;
+            long lval_;
+            bool bval_;
+
+            unsigned precision_;
+
+            DCCLCppType type_;
+        };
+
+        std::ostream& operator<<(std::ostream& os, const acomms::DCCLMessageVal& mv);
+        std::ostream& operator<<(std::ostream& os, const std::vector<acomms::DCCLMessageVal>& vm);
+    }
+
 }
 
-
-
 #endif

=== modified file 'src/acomms/libdccl/message_var.cpp'
--- src/acomms/libdccl/message_var.cpp	2010-06-15 04:51:47 +0000
+++ src/acomms/libdccl/message_var.cpp	2010-07-15 12:38:39 +0000
@@ -19,21 +19,21 @@
 
 #include <boost/foreach.hpp>
 
-#include "util/tes_utils.h"
+#include "goby/util/string.h"
 
 #include "message_var.h"
 #include "message_val.h"
 #include "dccl_constants.h"
 #include "message_algorithms.h"
 
-dccl::MessageVar::MessageVar()
+goby::acomms::DCCLMessageVar::DCCLMessageVar()
     : array_length_(1),
       is_key_frame_(true),
       source_set_(false),
-      ap_(AlgorithmPerformer::getInstance())
+      ap_(DCCLAlgorithmPerformer::getInstance())
 { }
 
-void dccl::MessageVar::initialize(const std::string& trigger_var)
+void goby::acomms::DCCLMessageVar::initialize(const std::string& trigger_var)
 {
     // add trigger_var_ as source_var for any message_vars without a source
     if(!source_set_)
@@ -43,30 +43,30 @@
 
 }
 
-void dccl::MessageVar::set_defaults(std::map<std::string,std::vector<MessageVal> >& vals, unsigned modem_id, unsigned id)
+void goby::acomms::DCCLMessageVar::set_defaults(std::map<std::string,std::vector<DCCLMessageVal> >& vals, unsigned modem_id, unsigned id)
 {
     vals[name_].resize(array_length_);    
 
-    std::vector<MessageVal>& vm = vals[name_];
+    std::vector<DCCLMessageVal>& vm = vals[name_];
 
-    for(std::vector<MessageVal>::size_type i = 0, n = vm.size(); i < n; ++i)
+    for(std::vector<DCCLMessageVal>::size_type i = 0, n = vm.size(); i < n; ++i)
         set_defaults_specific(vm[i], modem_id, id);
 
 }
 
     
-void dccl::MessageVar::var_encode(std::map<std::string,std::vector<MessageVal> >& vals, boost::dynamic_bitset<unsigned char>& bits)
+void goby::acomms::DCCLMessageVar::var_encode(std::map<std::string,std::vector<DCCLMessageVal> >& vals, boost::dynamic_bitset<unsigned char>& bits)
 {    
-    // ensure that every MessageVar has the full number of (maybe blank) MessageVals
+    // ensure that every DCCLMessageVar has the full number of (maybe blank) DCCLMessageVals
     vals[name_].resize(array_length_);
 
     // copy so algorithms can modify directly and not affect other algorithms' use of original values
-    std::vector<MessageVal> vm = vals[name_];
+    std::vector<DCCLMessageVal> vm = vals[name_];
     
     // write all the delta values first
     is_key_frame_ = false;
     
-    for(std::vector<MessageVal>::size_type i = 0, n = vm.size(); i < n; ++i)
+    for(std::vector<DCCLMessageVal>::size_type i = 0, n = vm.size(); i < n; ++i)
     {
         for(std::vector<std::string>::size_type j = 0, m = algorithms_.size(); j < m; ++j)
             ap_->algorithm(vm[i], i, algorithms_[j], vals);
@@ -83,7 +83,7 @@
     encode_value(key_val_, bits);
 }
 
-void dccl::MessageVar::encode_value(const MessageVal& val, boost::dynamic_bitset<unsigned char>& bits)
+void goby::acomms::DCCLMessageVar::encode_value(const DCCLMessageVal& val, boost::dynamic_bitset<unsigned char>& bits)
 {
     bits <<= calc_size();
     
@@ -94,7 +94,7 @@
 }
 
 
-void dccl::MessageVar::var_decode(std::map<std::string,std::vector<MessageVal> >& vals, boost::dynamic_bitset<unsigned char>& bits)
+void goby::acomms::DCCLMessageVar::var_decode(std::map<std::string,std::vector<DCCLMessageVal> >& vals, boost::dynamic_bitset<unsigned char>& bits)
 {
     vals[name_].resize(array_length_);
     
@@ -106,7 +106,7 @@
         boost::dynamic_bitset<unsigned char> remove_bits = bits;
         remove_bits.resize(calc_size());
 
-        MessageVal val = decode_specific(remove_bits);
+        DCCLMessageVal val = decode_specific(remove_bits);
         
         bits >>= calc_size();