message_val.h

Go to the documentation of this file.

// Copyright 2009-2021:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// The Goby Libraries are distributed in the hope that they will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_MOOS_TRANSITIONAL_MESSAGE_VAL_H
#define GOBY_MOOS_TRANSITIONAL_MESSAGE_VAL_H
 
#include <iostream> // for ostream
#include <string>   // for string, basic_string
#include <vector>   // for vector
 
#include "dccl_constants.h" // for DCCLCppType, cpp_notype
 
namespace goby
{
namespace moos
{
namespace transitional
{
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 DCCLMessageVal& mv);
std::ostream& operator<<(std::ostream& os, const std::vector<DCCLMessageVal>& vm);
} // namespace transitional
} // namespace moos
} // namespace goby
 
#endif