Value.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_VALUE_H_
#define SimTK_SimTKCOMMON_VALUE_H_

/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2005-15 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon/internal/common.h"

#include "SimTKcommon/internal/String.h"
#include "SimTKcommon/internal/Exception.h"

#include <limits>
#include <typeinfo>
#include <sstream>
#include <utility>

namespace SimTK {
  // Forward declaration.
  template<typename T> class Value;

//==============================================================================
//                             ABSTRACT VALUE
//==============================================================================
class AbstractValue {
public:
    virtual AbstractValue* clone() const = 0;

    virtual String getTypeName() const = 0;  

    virtual String getValueAsString() const = 0;

    virtual bool isCompatible(const AbstractValue& other) const = 0;

    virtual void compatibleAssign(const AbstractValue& source) = 0;
    
    AbstractValue& operator=(const AbstractValue& v) 
    {   compatibleAssign(v); return *this; }

    template <typename T>
    const T& getValue() const {
      return Value<T>::downcast(*this).get();
    }

    template <typename T>
    T& updValue() {
      return Value<T>::updDowncast(*this).upd();
    }

    virtual ~AbstractValue() {}   
};

inline std::ostream& operator<<(std::ostream& o, const AbstractValue& v) 
{   o << v.getValueAsString(); return o; }



//==============================================================================
//                               VALUE <T>
//==============================================================================
template <class T> class Value : public AbstractValue {
public:
    Value() {}

    explicit Value(const T& value) : m_thing(value) {}

    explicit Value(const T&& value) : m_thing(std::move(value)) {}

    ~Value() = default;

    Value(const Value& value) : m_thing(value.m_thing) {}

    Value(const Value&& value) : m_thing(std::move(value.m_thing)) {}

    Value& operator=(const Value& value) 
    {   m_thing = value.m_thing; return *this; }

    Value& operator=(const Value&& value) 
    {   m_thing = std::move(value.m_thing); return *this; }
 
    Value& operator=(const T& value) 
    {   m_thing = value; return *this; }

    Value& operator=(const T&& value) 
    {   m_thing = std::move(value); return *this; }
  
    const T& get() const {return m_thing;}

    T& upd() {return m_thing;}
 
    void set(const T& value)  {m_thing = value;}   

    void set(const T&& value)  {m_thing = std::move(value);}   

    operator const T&() const {return get();}

    operator T&() {return upd();}

    Value* clone() const override {return new Value(*this);}

    bool isCompatible(const AbstractValue& value) const override 
    {   return isA(value); }

    void compatibleAssign(const AbstractValue& value) override {
        if (!isA(value)) 
            SimTK_THROW2(Exception::IncompatibleValues,value.getTypeName(),
                         getTypeName());
        *this = downcast(value);
    }

    String getTypeName() const override {return NiceTypeName<T>::namestr();}

    String getValueAsString() const override 
    {   return "Value<" + getTypeName() + ">"; }
    
    static bool isA(const AbstractValue& value)
    {   return dynamic_cast<const Value*>(&value) != nullptr; }

    static const Value& downcast(const AbstractValue& value)
    {   return SimTK_DYNAMIC_CAST_DEBUG<const Value&>(value); }

    static Value& updDowncast(AbstractValue& value)
    {   return SimTK_DYNAMIC_CAST_DEBUG<Value&>(value); }

    static Value& downcast(AbstractValue& value) {return updDowncast(value);}

private:
    T   m_thing;
};



} // namespace SimTK

#endif // SimTK_SimTKCOMMON_VALUE_H_