uabstractclient.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2004, 2006-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 URBI_UABSTRACTCLIENT_HH
# define URBI_UABSTRACTCLIENT_HH

# include <libport/cstdio>
# include <libport/sys/types.h>
# include <libport/cstring>
# include <libport/cstdlib>
# include <cstdarg>

# include <list>
# include <iostream>
# include <string>

# include <libport/compiler.hh>
# include <libport/fwd.hh>
# include <libport/lockable.hh>
# include <libport/traits.hh>

# include <urbi/fwd.hh>
# include <urbi/export.hh>
# include <urbi/ubinary.hh>
# include <urbi/umessage.hh>

namespace urbi
{

  enum UCallbackAction
    {
      URBI_CONTINUE=0,
      URBI_REMOVE
    };

  enum { URBI_MAX_TAG_LENGTH = 64 };

  typedef unsigned int UCallbackID;

# define UINVALIDCALLBACKID 0

  typedef UCallbackAction (*UCallback)             (const UMessage&msg);

  typedef UCallbackAction (*UCustomCallback)       (void * callbackData,
                                                    const UMessage&msg);


  //used internaly
  class UCallbackInfo
  {
  public:
    UCallbackInfo(UCallbackWrapper &w);
    bool operator==(UCallbackID id) const;

    char tag[URBI_MAX_TAG_LENGTH];
    UCallbackWrapper& callback;
    UCallbackID id;
  };

  //used internaly
  class UClientStreambuf;


  class LockableOstream: public std::ostream
  {
  public:
    LockableOstream(std::streambuf* sb)
    : std::ostream(sb)
    {
    }
    mutable libport::Lockable sendBufferLock;
  };



  class URBI_SDK_API UAbstractClient : public LockableOstream
  {
  public:
    enum { URBI_BUFLEN = 128000 };
    enum { URBI_PORT = 54000 } ;
    static const char* default_host();

    typedef int error_type;


    UAbstractClient(const std::string& host = default_host(),
                    unsigned port = URBI_PORT,
                    size_t buflen = URBI_BUFLEN,
                    bool server = false);

    virtual ~UAbstractClient();

    bool init() const;
    error_type error() const;

    /*----------.
    | Sending.  |
    `----------*/


    ATTRIBUTE_PRINTF(2, 3)
    error_type send(const char* format, ...);

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

    error_type send(const urbi::UValue& v);

    error_type send(std::istream& is);

    error_type sendBinary(const void* data, size_t len,
                          const std::string& header);

    error_type sendBin(const void*, size_t len);

    ATTRIBUTE_PRINTF(4, 5)
    error_type sendBin(const void*, size_t len, const char* header, ...);

    error_type startPack();

    error_type endPack();

    ATTRIBUTE_PRINTF(2, 3)
    error_type pack(const char* format, ...);

    error_type vpack(const char* format, va_list args);

    error_type sendFile(const std::string& f);

    ATTRIBUTE_PRINTF(3, 4)
    UCallbackID sendCommand(UCallback, const char*, ...);

    ATTRIBUTE_PRINTF(4, 5)
    UCallbackID sendCommand(UCustomCallback, void *, const char*, ...);

    error_type sendSound(const char* device,
                  const urbi::USound& sound, const char* tag = 0);

    error_type putFile(const char* localName, const char* remoteName = 0);

    error_type putFile(const void* buffer, size_t length,
                       const char* remoteName);





    UCallbackID setCallback(UCallbackWrapper& callback, const char* tag);

    UCallbackID setErrorCallback(UCallbackWrapper& callback);

    UCallbackID setWildcardCallback(UCallbackWrapper& callback);

    UCallbackID setClientErrorCallback(UCallbackWrapper& callback);

    UCallbackID setCallback(UCallback, const char* tag);

    UCallbackID setCallback(UCustomCallback, void* callbackData,
                            const char* tag);




    template<class C>
    UCallbackID
    setCallback(C& ref, UCallbackAction (C::*)(const UMessage&),
                            const char * tag);
    template<class C, class P1>
    UCallbackID
    setCallback(C& ref, UCallbackAction (C::*)(P1, const UMessage&),
                P1, const char * tag);
    template<class C, class P1, class P2>
    UCallbackID
    setCallback(C& ref, UCallbackAction (C::*)(P1 , P2, const UMessage&),
                P1, P2,    const char * tag);

    template<class C, class P1, class P2, class P3>
    UCallbackID
      setCallback(C& ref, UCallbackAction (C::*)(P1 , P2, P3, const UMessage&),
                  P1, P2, P3, const char* tag);

    template<class C, class P1, class P2, class P3, class P4>
    UCallbackID
    setCallback(C& ref, UCallbackAction(C::*)(P1 , P2, P3, P4, const UMessage&),
                P1, P2, P3, P4, const char* tag);

    int getAssociatedTag(UCallbackID id, char* tag);

    int deleteCallback(UCallbackID id);

    std::string fresh();

    ATTRIBUTE_DEPRECATED
    void makeUniqueTag(char* tag);

    virtual void notifyCallbacks(const UMessage& msg);

    ATTRIBUTE_PRINTF(2, 3)
    virtual void printf(const char* format, ...) = 0;

    virtual unsigned int getCurrentTime() const = 0;

    virtual void setKeepAliveCheck(unsigned pingInterval,
                                   unsigned pongTimeout) = 0;

    const std::string& getServerName() const;

    unsigned getServerPort() const;
    void processRecvBuffer();

  private:
    bool process_recv_buffer_binary_();

    bool process_recv_buffer_text_();

  public:
    std::ostream& stream_get();

    static const char* CLIENTERROR_TAG;

    /* Inherited from LockableOstream libport::Lockable sendBufferLock;*/
  protected:
    void onConnection();

    virtual error_type onClose();
    bool closed_;

    virtual error_type effectiveSend(const void* buffer, size_t size) = 0;

    error_type effective_send(const void* buffer, size_t size);

    error_type effective_send(const char* buffer);

    error_type effective_send(const std::string& buffer);

    libport::Lockable listLock;

    UCallbackID addCallback(const char* tag, UCallbackWrapper& w);

    void clientError(std::string msg, int code = 0);
    void clientError(const char* msg = 0, int code = 0);

    std::string host_;
    unsigned port_;

    bool server_;

    size_t sendBufSize;
    size_t recvBufSize;

    error_type rc;

    char* recvBuffer;
    size_t recvBufferPosition;
    char* sendBuffer;

  public:
    const std::string& kernelVersion() const;
    int kernelMajor() const;
    int kernelMinor() const;
    virtual void waitForKernelVersion() const = 0;

  protected:
    std::string kernelVersion_;
    int kernelMajor_;
    int kernelMinor_;

    virtual UCallbackAction setVersion(const UMessage& msg);

  public:
    const std::string& connectionID() const;

  protected:
    std::string connectionID_;
    virtual UCallbackAction setConnectionID(const UMessage& msg);

  private:
    binaries_type bins;

    void bins_clear();

    void* binaryBuffer;
    size_t binaryBufferPosition;
    size_t binaryBufferLength;

    size_t parsePosition;
    bool inString;
    size_t nBracket;
    char* currentCommand;

    bool binaryMode;

    bool system;

    size_t endOfHeaderPosition;
    char currentTag[URBI_MAX_TAG_LENGTH];

    int currentTimestamp;

  protected:
    bool init_;

  public:
    int getCurrentTimestamp() const;

  private:
    typedef std::list<UCallbackInfo> callbacks_type;
    callbacks_type callbacks_;

    unsigned int counter_;

    std::ostream* stream_;

    friend class UClientStreambuf;
  };

  class UCallbackWrapper
  {
  public:
    virtual UCallbackAction operator ()(const UMessage&)=0;
    virtual ~UCallbackWrapper() {}
  };


  class UCallbackWrapperF
    : public UCallbackWrapper
  {
    UCallback cb;
  public:
    UCallbackWrapperF(UCallback cb) : cb(cb) {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return cb(msg);
    }
    virtual ~UCallbackWrapperF() {}
  };

  class UCallbackWrapperCF
    : public UCallbackWrapper
  {
    UCustomCallback cb;
    void* cbData;
  public:
    UCallbackWrapperCF(UCustomCallback cb, void* cbData)
      : cb(cb), cbData(cbData)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return cb(cbData, msg);
    }
    virtual ~UCallbackWrapperCF() {}
  };

  template<class C>
  class UCallbackWrapper0 :
    public UCallbackWrapper
  {
    C& instance;
    UCallbackAction (C::*func)(const UMessage&);
  public:
    UCallbackWrapper0(C& instance, UCallbackAction (C::*func)(const UMessage&))
      : instance(instance), func(func)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return (instance.*func)(msg);
    }
    virtual ~UCallbackWrapper0() {}
  };

  template<class C, class P1>
  class UCallbackWrapper1
    : public UCallbackWrapper
  {
    C& instance;
    UCallbackAction (C::*funcPtr)(P1, const UMessage&);
    typename libport::traits::remove_reference<P1>::type p1;
  public:
    UCallbackWrapper1(C& instance,
                      UCallbackAction (C::*func)(P1, const UMessage&), P1 p1)
      : instance(instance), funcPtr(func), p1(p1)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return (instance.*funcPtr)(p1, msg);
    }
    virtual ~UCallbackWrapper1()
    {}
  };

  template<class C, class P1, class P2>
  class UCallbackWrapper2 : public UCallbackWrapper
  {
    C& instance;
    UCallbackAction (C::*func)(P1, P2, const UMessage&);
    typename libport::traits::remove_reference<P1>::type p1;
    typename libport::traits::remove_reference<P2>::type p2;
  public:
    UCallbackWrapper2(
      C& instance, UCallbackAction (C::*func)(P1, P2, const UMessage&),
      P1 p1, P2 p2)
      : instance(instance), func(func), p1(p1), p2(p2)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return (instance.*func)(p1, p2, msg);
    }
    virtual ~UCallbackWrapper2()
    {}
  };


  template<class C, class P1, class P2, class P3>
  class UCallbackWrapper3 : public UCallbackWrapper
  {
    C& instance;
    UCallbackAction (C::*func)(P1, P2, P3, const UMessage&);
    typename libport::traits::remove_reference<P1>::type p1;
    typename libport::traits::remove_reference<P2>::type p2;
    typename libport::traits::remove_reference<P3>::type p3;
  public:
    UCallbackWrapper3(
      C& instance, UCallbackAction (C::*func)(P1, P2, P3, const UMessage&),
      P1 p1, P2 p2, P3 p3)
      : instance(instance), func(func), p1(p1), p2(p2), p3(p3)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return (instance.*func)(p1, p2, p3, msg);
    }
    virtual ~UCallbackWrapper3()
    {}
  };


  template<class C, class P1, class P2, class P3, class P4>
  class UCallbackWrapper4 : public UCallbackWrapper
  {
    C& instance;
    UCallbackAction (C::*func)(P1, P2, P3, P4, const UMessage&);
    typename libport::traits::remove_reference<P1>::type p1;
    typename libport::traits::remove_reference<P2>::type p2;
    typename libport::traits::remove_reference<P3>::type p3;
    typename libport::traits::remove_reference<P4>::type p4;
  public:
    UCallbackWrapper4(
      C& instance, UCallbackAction(C::*func)(P1, P2, P3, P4, const UMessage&),
      P1 p1, P2 p2, P3 p3, P4 p4)
      : instance(instance), func(func), p1(p1), p2(p2), p3(p3), p4(p4)
    {}
    virtual UCallbackAction operator ()(const UMessage& msg)
    {
      return (instance.*func)(p1, p2, p3, p4, msg);
    }
    virtual ~UCallbackWrapper4()
    {}
  };
  //overloaded callback generators



  inline UCallbackWrapper& callback(UCallback cb)
  {
    return *new UCallbackWrapperF(cb);
  }
  inline UCallbackWrapper& callback(UCustomCallback cb, void* data)
  {
    return *new UCallbackWrapperCF(cb, data);
  }


  template<class C> UCallbackWrapper&
  callback(C& ref, UCallbackAction (C::*func)(const UMessage&))
  {
    return *new UCallbackWrapper0<C>(ref, func);
  }

  template<class C, class P1> UCallbackWrapper&
  callback(C& ref, UCallbackAction (C::*func)(P1, const UMessage&), P1 p1)
  {
    return *new UCallbackWrapper1<C, P1>(ref, func, p1);
  }

  template<class C, class P1, class P2>  UCallbackWrapper&
  callback(C& ref, UCallbackAction (C::*func)(P1, P2, const UMessage&),
           P1 p1, P2 p2)
  {
    return *new UCallbackWrapper2<C, P1, P2>(ref, func, p1, p2);
  }

  template<class C, class P1, class P2, class P3> UCallbackWrapper&
  callback(C& ref, UCallbackAction (C::*func)(P1, P2, P3, const UMessage&),
           P1 p1, P2 p2, P3 p3)
  {
    return *new UCallbackWrapper3<C, P1, P2, P3>(ref, func, p1, p2, p3);
  }

  template<class C, class P1, class P2, class P3, class P4>  UCallbackWrapper&
  callback(C& ref, UCallbackAction (C::*func)(P1, P2, P3, P4, const UMessage&),
           P1 p1, P2 p2, P3 p3, P4 p4)
  {
    return *new UCallbackWrapper4<C, P1, P2, P3, P4>(ref, func, p1, p2, p3, p4);
  }



  //old-style addCallback, deprecated
  template<class C>
  UCallbackID
  UAbstractClient::setCallback(C& ref,
                               UCallbackAction (C::*func)(const UMessage&),
                               const char* tag)
  {
    return addCallback(tag,*new UCallbackWrapper0<C>(ref, func));
  }

  template<class C, class P1>
  UCallbackID
  UAbstractClient::setCallback(C& ref,
                               UCallbackAction (C::*func)(P1 , const UMessage&),
                               P1 p1, const char* tag)
  {
    return addCallback(tag, *new UCallbackWrapper1<C, P1>(ref, func, p1));
  }

  template<class C, class P1, class P2>
  UCallbackID
  UAbstractClient::setCallback(
    C& ref, UCallbackAction (C::*func)(P1, P2, const UMessage&),
    P1 p1, P2 p2, const char* tag)
  {
    return addCallback(tag, *new UCallbackWrapper2<C, P1, P2>
                       (ref, func, p1, p2));
  }

  template<class C, class P1, class P2, class P3>
  UCallbackID
  UAbstractClient::setCallback(
    C& ref, UCallbackAction (C::*func)(P1, P2, P3, const UMessage&),
    P1 p1 , P2 p2, P3 p3, const char* tag)
  {
    return addCallback(tag, *new UCallbackWrapper3<C, P1, P2, P3>
                       (ref, func, p1, p2, p3));
  }

  template<class C, class P1, class P2, class P3, class P4>
  UCallbackID
  UAbstractClient::setCallback(
    C& ref, UCallbackAction (C::*func)(P1, P2, P3, P4, const UMessage&),
    P1 p1, P2 p2, P3 p3, P4 p4, const char* tag)
  {
    return addCallback(tag, *new UCallbackWrapper4<C, P1, P2, P3, P4>
                       (ref, func, p1, p2, p3, p4));
  }



# ifndef URBI
#  define URBI(A)                               \
  ::urbi::unarmorAndSend(#A)
# endif

  static const char semicolon = ';';
  static const char pipe = '|';
  static const char parallel = '&';
  static const char comma = ',';

  URBI_SDK_API
  void execute(void);

  URBI_SDK_API
  void exit(int code);

  URBI_SDK_API
  UClient& connect(const std::string& host);

  URBI_SDK_API
  void disconnect(UClient &client);

  /*-----------------.
  | Default client.  |
  `-----------------*/

  URBI_SDK_API
  UClient* getDefaultClient();

  URBI_SDK_API
  UClient& get_default_client();

  URBI_SDK_API
  void setDefaultClient(UClient* cl);

  URBI_SDK_API
  std::string getClientConnectionID(const UAbstractClient* cli);

# ifndef DISABLE_IOSTREAM

  URBI_SDK_API
  std::ostream&
  unarmorAndSend(const char* str,
                 UAbstractClient* c = (UAbstractClient*)getDefaultClient());
# endif

  URBI_SDK_API
  extern UClient* defaultClient;

  URBI_SDK_API
  std::ostream& default_stream();

} // namespace urbi

# include <urbi/uabstractclient.hxx>

#endif // URBI_UABSTRACTCLIENT_HH