Player

• Frontpage
• Contents

User

• Installation
• Quick start
• Supported devices
• Tutorials
• Utilities
• Client libraries
• FAQ
• Help

Developer

• Architecture
• libplayercore
  • interfaces
• libplayerdrivers
  • drivers
• libplayererror
• libplayertcp
• libplayerxdr
• TODO

Online

Homepage
Download
Project
Bugs
Help

playerclient.h

/*
  $Id: playerclient.h,v 1.20.2.2 2006/09/25 17:00:16 gerkey Exp $
*/

#ifndef PLAYERCLIENT_H
#define PLAYERCLIENT_H

#include "libplayerc++/playerc++config.h"
#include "libplayerc++/utility.h"

#include <string>
#include <list>

#ifdef HAVE_BOOST_SIGNALS
  #include <boost/signal.hpp>
  #include <boost/bind.hpp>
#endif

#ifdef HAVE_BOOST_THREAD
  #include <boost/thread/mutex.hpp>
  #include <boost/thread/thread.hpp>
  #include <boost/thread/xtime.hpp>
#else
  // we have to define this so we don't have to
  // comment out all the instances of scoped_lock
  // in all the proxies
  namespace boost
  {
    class thread
    {
      public:
        thread() {};
    };

    class mutex
    {
      public:
        mutex() {};
        class scoped_lock
        {
          public: scoped_lock(mutex m) {};
        };
    };
  }

#endif

namespace PlayerCc
{

class ClientProxy;

class PlayerClient
{
  friend class ClientProxy;

  // our thread type
  typedef boost::thread thread_t;

  // our mutex type
  typedef boost::mutex mutex_t;

  private:
    // list of proxies associated with us
    std::list<PlayerCc::ClientProxy*> mProxyList;

    std::list<playerc_device_info_t> mDeviceList;

    // Connect to the indicated host and port.
    // @exception throws PlayerError if unsuccessfull
    void Connect(const std::string aHostname, uint aPort);

    // Disconnect from server.
    void Disconnect();

    //  our c-client from playerc
    playerc_client_t* mClient;

    // The hostname of the server, stored for convenience
    std::string mHostname;

    // The port number of the server, stored for convenience
    uint mPort;

    // Which transport (TCP or UDP) we're using
    unsigned int mTransport;

    // Is the thread currently stopped or stopping?
    bool mIsStop;

    // This is the thread where we run @ref Run()
    thread_t* mThread;

    // A helper function for starting the thread
    void RunThread();

  public:

    PlayerClient(const std::string aHostname=PLAYER_HOSTNAME,
                 uint aPort=PLAYER_PORTNUM,
                 int transport=PLAYERC_TRANSPORT_TCP);

    ~PlayerClient();

    mutex_t mMutex;

    // ideally, we'd use the read_write mutex, but I was having some problems
    // (with their code) because it's under development
    //boost::read_write_mutex mMutex;

    void StartThread();

    void StopThread();

    void Run(uint aTimeout=10); // aTimeout in ms

    void Stop();

    bool Peek(uint timeout=0);

    void SetRetryLimit(int limit) { playerc_client_set_retry_limit(this->mClient,limit); }

    int GetRetryLimit() { return(this->mClient->retry_limit); }

    void SetRetryTime(double time) { playerc_client_set_retry_time(this->mClient,time); }

    double GetRetryTime() { return(this->mClient->retry_time); }

    void Read();

    void ReadIfWaiting();

//    /// @brief You can change the rate at which your client receives data from the
//    /// server with this method.  The value of @p freq is interpreted as Hz;
//    /// this will be the new rate at which your client receives data (when in
//    /// continuous mode).
//    ///
//    /// @exception throws PlayerError if unsuccessfull
//     void SetFrequency(uint aFreq);

    void SetDataMode(uint aMode);

    void SetReplaceRule(bool aReplace,
                        int aType = -1,
                        int aSubtype = -1,
                        int aInterf = -1);

    void RequestDeviceList();

    std::list<playerc_device_info_t> GetDeviceList();

    std::string GetHostname() const { return(mHostname); };

    uint GetPort() const { return(mPort); };

    int LookupCode(std::string aName) const;

    std::string LookupName(int aCode) const;
};



}

namespace std
{
  std::ostream& operator << (std::ostream& os, const PlayerCc::PlayerClient& c);
}

#endif

---

Last updated 12 September 2005 21:38:45