acomms/libdccl/dccl.h

// copyright 2009 t. schneider tes@mit.edu
// 
// 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
//
// 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/>.

#ifndef DCCL20091211H
#define DCCL20091211H

#include <string>
#include <set>
#include <map>
#include <ostream>
#include <stdexcept>
#include <vector>

#include "goby/util/time.h"
#include "goby/util/logger.h"

#include "goby/core/core_constants.h"
#include "message.h"
#include "message_val.h"
#include "dccl_exception.h"
#include "goby/protobuf/dccl.pb.h"
#include "goby/protobuf/modem_message.pb.h"
#include "goby/acomms/acomms_helpers.h"

namespace goby
{
    namespace util
    { class FlexOstream; }


    namespace acomms
    {
        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;
        }

    
        std::ostream& operator<< (std::ostream& out, const std::set<unsigned>& s);
        std::ostream& operator<< (std::ostream& out, const std::set<std::string>& s);


        class DCCLCodec 
        {
          public:



            DCCLCodec(std::ostream* log = 0);

            ~DCCLCodec() {}
        


            void set_cfg(const protobuf::DCCLConfig& cfg);

            void merge_cfg(const protobuf::DCCLConfig& cfg);
        
            void add_algorithm(const std::string& name, AlgFunction1 func);
        
            void add_adv_algorithm(const std::string& name, AlgFunction2 func);

            static void add_flex_groups(util::FlexOstream* tout);
            
        






            template<typename Key>
                void encode(const Key& k, std::string& bytes,
                            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), bytes, vm);
            }

            template<typename Key>
                void encode(const Key& k, std::string& bytes,
                            const std::map<std::string, std::vector<DCCLMessageVal> >& m)
            { encode_private(to_iterator(k), bytes, m); }

        
            void decode(const std::string& bytes,
                        std::map<std::string, DCCLMessageVal>& m)
            {
                std::map<std::string, std::vector<DCCLMessageVal> > vm;
                
                decode_private(bytes, 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)));
            }
        
            void decode(const std::string& bytes,
                        std::map<std::string, std::vector<DCCLMessageVal> >& m)
            { decode_private(bytes, m); }
            
        
        



            template<typename Key>
                std::string summary(const Key& k) const
            { return to_iterator(k)->get_display(); }
            std::string summary() const;

            template<typename Key>
                std::string brief_summary(const Key& k) const
            { return to_iterator(k)->get_short_display(); }
            std::string brief_summary() const;

            unsigned message_count() { return messages_.size(); }

            template<typename Key>
                unsigned get_repeat(const Key& k)
            { return to_iterator(k)->repeat(); }
        
            std::set<unsigned> all_message_ids();
            std::set<std::string> all_message_names();
            template<typename Key>
                std::map<std::string, std::string> message_var_names(const Key& k) const
            { return to_iterator(k)->message_var_names(); }
        
            std::string id2name(unsigned id) {return to_iterator(id)->name();}
            unsigned name2id(const std::string& name) {return to_iterator(name)->id();}
            
            


        
















            template<typename Key>
                void pubsub_encode(const Key& k,
                                   protobuf::ModemDataTransmission* msg,
                                   const std::map<std::string, std::vector<DCCLMessageVal> >& pubsub_vals)
            {
                std::vector<DCCLMessage>::iterator it = to_iterator(k);
                
                if(log_)
                {
                    *log_ << group("dccl_enc") << "starting publish/subscribe encode for " << it->name() << std::endl;
                    *log_ << group("dccl_enc") << "publish/subscribe variables are: " << std::endl;
                    
                    typedef std::pair<std::string, std::vector<DCCLMessageVal> > P;
                    BOOST_FOREACH(const P& p, pubsub_vals)                    
                    {
                        if(!p.first.empty())
                        {
                            BOOST_FOREACH(const DCCLMessageVal& mv, p.second)
                                *log_ << group("dccl_enc") << "\t" << p.first << ": " <<  mv << std::endl;
                        }   
                    }                 
                }

                
                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);

                if(log_) *log_ << group("dccl_enc") << "message published to variable: " <<
                            get_outgoing_hex_var(it->id()) << std::endl;
            }

            template<typename Key>
                void pubsub_encode(const Key& k,
                                   protobuf::ModemDataTransmission* 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);
            }

        
            void pubsub_decode(const protobuf::ModemDataTransmission& msg,
                               std::multimap<std::string, DCCLMessageVal>* pubsub_vals)
                               
            {
                std::map<std::string, std::vector<DCCLMessageVal> > vals;
                std::vector<DCCLMessage>::iterator it = decode_private(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);

                if(log_)
                {
                    *log_ << group("dccl_dec") << "publish/subscribe variables are: " << std::endl;
                    typedef std::pair<std::string, DCCLMessageVal> P;
                    BOOST_FOREACH(const P& p, *pubsub_vals)
                    {
                        
                        *log_ << group("dccl_dec") << "\t" << p.first << ": " << p.second << std::endl;
                    }                 
                    *log_ << group("dccl_dec") << "finished publish/subscribe decode for " << it->name() << std::endl;
                }
            }
        
        
            template<typename Key>
                std::set<std::string> get_pubsub_src_vars(const Key& k)
            { return to_iterator(k)->get_pubsub_src_vars(); }

            template<typename Key>
                std::set<std::string> get_pubsub_all_vars(const Key& k)
            { return to_iterator(k)->get_pubsub_all_vars(); }

            template<typename Key>
                std::set<std::string> get_pubsub_encode_vars(const Key& k)
            { return to_iterator(k)->get_pubsub_encode_vars(); }

            template<typename Key>
                std::set<std::string> get_pubsub_decode_vars(const Key& k)
            { return to_iterator(k)->get_pubsub_decode_vars(); }
        
            template<typename Key>
                std::string get_outgoing_hex_var(const Key& k)
            { return to_iterator(k)->out_var(); }

            template<typename Key>
                std::string get_incoming_hex_var(const Key& k)
            { return to_iterator(k)->in_var(); }

        
            bool is_publish_trigger(std::set<unsigned>& id, const std::string& key, const std::string& value);

            bool is_time_trigger(std::set<unsigned>& id);

            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_;}

            // grab a reference to the manipulator manager used by the loaded XML messages
            const ManipulatorManager& manip_manager() const { return manip_manager_; }

            
        
        

        
          private:
            std::set<unsigned> add_xml_message_file(const std::string& xml_file);
            
            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
            std::vector<DCCLMessage>::iterator decode_private(std::string in,
                                std::map<std::string, std::vector<DCCLMessageVal> >& out);
        
            void encode_private(std::vector<DCCLMessage>::iterator it,
                                protobuf::ModemDataTransmission* out_msg,
                                const std::map<std::string, std::vector<DCCLMessageVal> >& in);
        
            std::vector<DCCLMessage>::iterator decode_private(const protobuf::ModemDataTransmission& 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);

            void process_cfg();
            
          private:
            std::ostream* log_;
            
            std::vector<DCCLMessage> messages_;
            std::map<std::string, size_t>  name2messages_;
            std::map<unsigned, size_t>     id2messages_;

            protobuf::DCCLConfig cfg_;

            boost::posix_time::ptime start_time_;

            // SHA256 hash of the crypto passphrase
            std::string crypto_key_;
            
            ManipulatorManager manip_manager_;    
            
        };
        
        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);
            }
            std::string& str() { 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);
                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