message_val.h

// Copyright 2009-2018 Toby Schneider (http://gobysoft.org/index.wt/people/toby)
//                     GobySoft, LLC (2013-)
//                     Massachusetts Institute of Technology (2007-2014)
//                     Community contributors (see AUTHORS file)
//
//
// 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 MESSAGE_VAL20091211H
#define MESSAGE_VAL20091211H

#include <iostream>

#include "dccl_constants.h"

namespace goby
{
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 goby

#endif