ucontext-impl.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2009-2011, 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 UCONTEXT_IMPL_HH
# define UCONTEXT_IMPL_HH

#include <set>

#include <boost/function.hpp>
#include <libport/system-warning-push.hh>
#include <boost/thread.hpp>
#include <libport/system-warning-pop.hh>

#include <libport/asio.hh>

#include <urbi/fwd.hh>
#include <urbi/uprop.hh>

namespace urbi
{
  namespace impl
  {
    class URBI_SDK_API UContextImpl
    {
    public:
      virtual ~UContextImpl() = 0;
      void init();
      bool bind(const std::string& name, std::string rename = std::string());
      virtual void newUObjectClass(urbi::baseURBIStarter* s) = 0;
      virtual void newUObjectHubClass(urbi::baseURBIStarterHub* s) = 0;
      virtual UObjectHub* getUObjectHub(const std::string& n);
      virtual UObject* getUObject(const std::string& n);
      virtual void uobject_unarmorAndSend(const char* str) = 0;

      virtual void send(const char* str) = 0;

      virtual void send(const void* buf, size_t size) = 0;

      void send(const std::string& s);

      virtual void call(const std::string& object,
                        const std::string& method,
                        UAutoValue v1 = UAutoValue(),
                        UAutoValue v2 = UAutoValue(),
                        UAutoValue v3 = UAutoValue(),
                        UAutoValue v4 = UAutoValue(),
                        UAutoValue v5 = UAutoValue(),
                        UAutoValue v6 = UAutoValue()) = 0;

      virtual void declare_event(const UEvent* owner) = 0;

      virtual void emit(const std::string& object,
                        UAutoValue& v1,
                        UAutoValue& v2,
                        UAutoValue& v3,
                        UAutoValue& v4,
                        UAutoValue& v5,
                        UAutoValue& v6,
                        UAutoValue& v7) = 0;

      virtual UObjectMode getRunningMode() const = 0;
      virtual std::pair<int, int> kernelVersion() const = 0;

      virtual void yield() const = 0;

      virtual void yield_until(libport::utime_t deadline) const = 0;

      virtual void yield_for(libport::utime_t delay) const;

      virtual void yield_until_things_changed() const = 0;

      virtual void side_effect_free_set(bool s) = 0;
      virtual bool side_effect_free_get() const = 0;
      virtual UVarImpl* getVarImpl() = 0;
      virtual UObjectImpl* getObjectImpl() = 0;
      virtual UGenericCallbackImpl* getGenericCallbackImpl() = 0;
      virtual void registerObject(UObject*o);
      virtual TimerHandle setTimer(UTimerCallback* cb) = 0;
      virtual void registerHub(UObjectHub*);
      virtual void removeHub(UObjectHub*) = 0;
      virtual void setHubUpdate(UObjectHub*, ufloat) = 0;
      virtual void instanciated(UObject*) = 0;
      typedef boost::unordered_map<std::string, UObject*>  objects_type;
      objects_type objects;
      typedef boost::unordered_map<std::string, UObjectHub*> hubs_type;
      hubs_type hubs;
      std::set<void*> initialized;

      class CleanupStack
      {
      public:
        CleanupStack(UContextImpl& owner);
        ~CleanupStack();
      private:
        UContextImpl& owner_;
      };

      template<typename T>
      void addCleanup(T* ptr);

      void addCleanup(boost::function0<void> op);

      void pushCleanupStack();
      void popCleanupStack();

      virtual void lock() = 0;
      virtual void unlock() = 0;
      virtual boost::asio::io_service& getIoService() = 0;

      typedef void(*RTPSend)(UObject* rtp, const UValue& v);
      typedef void(*RTPSendGrouped)(UObject* rtp, const std::string&,
                                    const UValue&,
                                   libport::utime_t);
      RTPSend rtpSend;
      RTPSendGrouped rtpSendGrouped;
    private:
      typedef std::vector<std::vector<boost::function0<void> > > CleanupList;
      boost::thread_specific_ptr<CleanupList> cleanup_list_;
    };

    class URBI_SDK_API UObjectImpl
    {
    public:
      virtual ~UObjectImpl() = 0;
      // Called by uobject constructor
      virtual void initialize(UObject* owner) = 0;
      virtual void clean() = 0;
      virtual void setUpdate(ufloat period) = 0;
      virtual bool removeTimer(TimerHandle h) = 0;
    };

    class URBI_SDK_API UVarImpl
    {
    public:
      virtual ~UVarImpl() = 0;
      virtual void initialize(UVar* owner) = 0;
      virtual void clean() = 0;
      virtual void setOwned() = 0;
      virtual void sync() = 0;
      virtual void request() = 0;
      virtual void keepSynchronized() = 0;
      // Set the UVar value from v. Must deep-copy unless bypass mode is enabled
      virtual void set(const UValue& v) = 0;
      virtual const UValue& get() const = 0;
      virtual UDataType type() const = 0;
      virtual UValue getProp(UProperty prop) = 0;
      virtual void setProp(UProperty prop, const UValue& v) = 0;
      virtual bool setBypass(bool enable) = 0;
      virtual time_t timestamp() const = 0;
      virtual void unnotify() = 0;
      virtual void useRTP(bool enable) = 0;
      virtual void setInputPort(bool enable) = 0;
    };
  }
}

# include <urbi/ucontext-impl.hxx>

#endif