acomms/libdccl/message_val.h

// copyright 2008, 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 MESSAGE_VAL20091211H
#define MESSAGE_VAL20091211H

#include <iostream>

#include "dccl_constants.h"

namespace goby
{
    namespace acomms
    {
    
        class DCCLMessageVal
        {
          public:
            enum { MAX_DBL_PRECISION = 15 };
        


            DCCLMessageVal();
        
            DCCLMessageVal(const std::string& s);
        
            DCCLMessageVal(const char* s);
        
            DCCLMessageVal(double d, int p = MAX_DBL_PRECISION);
        
            DCCLMessageVal(long l);
        
            DCCLMessageVal(int i);
        
            DCCLMessageVal(float f);
        
            DCCLMessageVal(bool b);

            DCCLMessageVal(const std::vector<DCCLMessageVal>& vm);

        
        



            void set(std::string sval);
            void set(double dval, int precision = MAX_DBL_PRECISION);
            void set(long lval);
            void set(bool bval);

        




            bool get(std::string& s) const;
            bool get(bool& b) const;
            bool get(long& t) const;        
            bool get(double& d) const;

            operator double() const;

            operator bool() const;

            operator std::string() const;

            operator long() const;

            operator int() const;

            operator unsigned() const;

            operator float() const;

            operator std::vector<DCCLMessageVal>() const;
        

            DCCLCppType type() const { return type_; }
        
            bool empty() const { return type_ == cpp_notype; }        

            unsigned precision() const { return precision_; }
        



            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