uvar.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2007, 2008, 2009, 2010, Gostai S.A.S.
 *
 * This software is provided "as is" without warranty of any kind,
 * either expressed or implied, including but not limited to the
 * implied warranties of fitness for a particular purpose.
 *
 * See the LICENSE file for more information.
 */

#ifndef URBI_UVAR_HH
# define URBI_UVAR_HH

# include <iosfwd>
# include <string>

# include <libport/fwd.hh>
# include <libport/ufloat.hh>

# include <urbi/ucontext.hh>
# include <urbi/uvalue.hh>
# include <urbi/uprop.hh>
# include <urbi/uproperty.hh>

namespace urbi
{
  class URBI_SDK_API UVar: public UContext
  {
  public:
    UVar();
    UVar(const std::string&, impl::UContextImpl* = 0);
    UVar(const std::string&, const std::string&, impl::UContextImpl* = 0);
    UVar(UObject&, const std::string&, impl::UContextImpl* = 0);
    UVar(const UVar&);
  private:
    UVar& operator=(const UVar&);
  public:
    ~UVar();

    // Bind to \a object.slot.
    void init(const std::string& varname, impl::UContextImpl* = 0);
    void init(const std::string& object, const std::string& slot,
              impl::UContextImpl* = 0);
    void setOwned();

    UDataType type() const;

    void syncValue();

    void keepSynchronized();

    void reset (ufloat);

    UVar& operator=(ufloat);
    UVar& operator=(const std::string&);
    UVar& operator=(const UBinary&);
    UVar& operator=(const UImage& i);
    UVar& operator=(const USound& s);

    UVar& operator=(const UList& l);

    UVar& operator=(const UDictionary& d);

    UVar& operator=(const UValue& v);

    template<typename T>
    UVar& operator=(const T&);

    template<typename T>
    bool operator ==(const T&) const;

    template<typename T> T as(T*) const;
    template<typename T> T as() const;
    template<typename T> T& fill(T&) const;

    operator int() const;
    operator bool() const;

    // Cast to a UBinary to make copy through this operator.
    operator const UBinary&() const;

    operator UBinary*() const;

    operator UImage() const;

    operator USound() const;

    operator ufloat() const;
    operator std::string() const;
    operator UList() const;
    operator UDictionary() const;

    void unnotify();

    ufloat& in();
    ufloat& out();

    bool owned;

    UProp rangemin;
    UProp rangemax;
    UProp speedmin;
    UProp speedmax;
    UProp delta;
    UProp blend;
    UProp constant;

    UValue getProp(UProperty prop);
    void setProp(UProperty prop, const UValue &v);
    void setProp(UProperty prop, ufloat v);
    void setProp(UProperty prop, const char * v);
    void setProp(UProperty prop, const std::string& v)
    {
      setProp(prop, v.c_str());
    }

    bool setBypass(bool enable=true);

    void useRTP(bool enable=true);
    impl::UVarImpl* impl_;
    const UValue& val() const;
    libport::utime_t timestamp() const;


    enum RtpMode {
      RTP_DEFAULT, 
      RTP_YES,     
      RTP_NO       
    };

    void check() const;
  private:
    UVardata* vardata;
    void __init();

# define PRIVATE(Type, Name)                    \
  public:                                       \
    Type get_ ##  Name ()                       \
    {                                           \
      return Name;                              \
    }                                           \
    Type get_ ##  Name () const                 \
    {                                           \
      return Name;                              \
    }                                           \
    void set_ ##  Name (const Type& v)          \
    {                                           \
      Name = v;                                 \
    }                                           \
  private:                                      \
    Type Name;

    PRIVATE(std::string, name)

    
    PRIVATE(bool, temp);

    PRIVATE(RtpMode, rtp);

    PRIVATE(bool, local);
# undef PRIVATE

    // Check that the invariants of this class are verified.
    bool invariant() const;
    friend class impl::UVarImpl;
  };

  /*-------------------------.
  | Inline implementations.  |
  `-------------------------*/

#   define VAR_PROP_INIT                        \
  rangemin(*this, PROP_RANGEMIN),               \
  rangemax(*this, PROP_RANGEMAX),               \
  speedmin(*this, PROP_SPEEDMIN),               \
  speedmax(*this, PROP_SPEEDMAX),               \
  delta(*this, PROP_DELTA),                     \
  blend(*this, PROP_BLEND),                     \
  constant(*this, PROP_CONSTANT)

  URBI_SDK_API
  std::ostream& operator<< (std::ostream& o, const urbi::UVar& u);

} // end namespace urbi

# include <urbi/uvar.hxx>

#endif // ! URBI_UVAR_HH