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

playerc++.h

/*
 *  Player - One Hell of a Robot Server
 *  Copyright (C) 2000-2003
 *     Brian Gerkey, Kasper Stoy, Richard Vaughan, & Andrew Howard
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/***************************************************************************
 * Desc: Player v2.0 C++ client
 * Authors: Brad Kratochvil, Toby Collett
 *
 * Date: 23 Sep 2005
 # CVS: $Id: playerc++.h,v 1.54.2.15 2007/12/05 21:57:34 gerkey Exp $
 **************************************************************************/


#ifndef PLAYERCC_H
#define PLAYERCC_H

#include <cmath>
#include <string>
#include <list>

#include "libplayerc/playerc.h"
#include "libplayerc++/utility.h"
#include "libplayerc++/playerc++config.h"
#include "libplayerc++/playerclient.h"
#include "libplayerc++/playererror.h"
#include "libplayerc++/clientproxy.h"

#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>
#endif

namespace PlayerCc
{

// /**
// * The @p SomethingProxy class is a template for adding new subclasses of
// * ClientProxy.  You need to have at least all of the following:
// */
// class SomethingProxy : public ClientProxy
// {
//
//   private:
//
//     // Subscribe
//     void Subscribe(uint aIndex);
//     // Unsubscribe
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_something_t *mDevice;
//
//   public:
//     // Constructor
//     SomethingProxy(PlayerClient *aPc, uint aIndex=0);
//     // Destructor
//     ~SomethingProxy();
//
// };

// ==============================================================
//
// These are alphabetized, please keep them that way!!!
//
// ==============================================================

class ActArrayProxy : public ClientProxy
{
  private:

   void Subscribe(uint aIndex);
   void Unsubscribe();

   // libplayerc data structure
   playerc_actarray_t *mDevice;

  public:

    ActArrayProxy(PlayerClient *aPc, uint aIndex=0);
    ~ActArrayProxy();

    void RequestGeometry(void);

    void SetPowerConfig(bool aVal);
    void SetBrakesConfig(bool aVal);
    void SetSpeedConfig(uint aJoint, float aSpeed);

    void MoveTo(uint aJoint, float aPos);
    void MoveAtSpeed(uint aJoint, float aSpeed);
    void MoveHome(int aJoint);

    uint GetCount(void) const { return GetVar(mDevice->actuators_count); }
    player_actarray_actuator_t GetActuatorData(uint aJoint) const;
    player_actarray_actuatorgeom_t GetActuatorGeom(uint aJoint) const;

    player_actarray_actuator_t operator [](uint aJoint)
      { return(GetActuatorData(aJoint)); }
};

class AioProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_aio_t *mDevice;

  public:

    AioProxy (PlayerClient *aPc, uint aIndex=0);
    ~AioProxy();

    uint GetCount() const { return(GetVar(mDevice->voltages_count)); };

    double GetVoltage(uint aIndex)  const
      { return(GetVar(mDevice->voltages[aIndex])); };

    void SetVoltage(uint aIndex, double aVoltage);

    double operator [](uint aIndex) const
      { return GetVoltage(aIndex); }

};

#if 0 // Not in libplayerc

class AudioProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audio_t *mDevice;

  public:

    AudioProxy(PlayerClient *aPc, uint aIndex=0)
    ~AudioProxy();

    uint GetCount() const { return(GetVar(mDevice->count)); };

    double GetFrequency(uint aIndex) const
      { return(GetVar(mDevice->frequency[aIndex])); };
    double GetAmplitude(uint aIndex) const
      { return(GetVar(mDevice->amplitude[aIndex])); };

    // Play a fixed-frequency tone
    void PlayTone(uint aFreq, uint aAmp, uint aDur);
};

class AudioDspProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audiodsp_t *mDevice;

  public:
    AudioDspProxy(PlayerClient *aPc, uint aIndex=0);
    ~AudioDspProxy

    uint SetFormat(int aFormat);

    uint SetRate(uint aRate);

    uint GetCount() const { return(GetVar(mDevice->count)); };

    double GetFrequency(uint aIndex) const
      { return(GetVar(mDevice->frequency[aIndex])); };
    double GetAmplitude(uint aIndex) const
      { return(GetVar(mDevice->amplitude[aIndex])); };

    void Configure(uint aChan, uint aRate, int16_t aFormat=0xFFFFFFFF);

    void RequestConfigure();

    void PlayTone(uint aFreq, uint aAmp, uint aDur);
    void PlayChirp(uint aFreq, uint aAmp, uint aDur,
                   const uint8_t aBitString, uint aBitStringLen);
    void Replay();

    void Print ();
};

class AudioMixerProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audiodsp_t *mDevice;

  public:

    AudioMixerProxy (PlayerClient *aPc, uint aIndex=0);

    void GetConfigure();

    void SetMaster(uint aLeft, uint aRight);
    void SetPCM(uint aLeft, uint aRight);
    void SetLine(uint aLeft, uint aRight);
    void SetMic(uint aLeft, uint aRight);
    void SetIGain(uint aGain);
    void SetOGain(uint aGain);

};

class BlinkenLightProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blinkenlight_t *mDevice;

  public:
    BlinkenLightProxy(PlayerClient *aPc, uint aIndex=0);
    ~BlinkenLightProxy();

    // true: indicator light enabled, false: disabled.
    bool GetEnable();

    void SetPeriod(double aPeriod);

    void SetEnable(bool aSet);
};

#endif

class BlobfinderProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blobfinder_t *mDevice;

  public:
    BlobfinderProxy(PlayerClient *aPc, uint aIndex=0);
    ~BlobfinderProxy();

    uint GetCount() const { return GetVar(mDevice->blobs_count); };
    playerc_blobfinder_blob_t GetBlob(uint aIndex) const
      { return GetVar(mDevice->blobs[aIndex]);};

    uint GetWidth() const { return GetVar(mDevice->width); };
    uint GetHeight() const { return GetVar(mDevice->height); };

    playerc_blobfinder_blob_t operator [](uint aIndex) const
      { return(GetBlob(aIndex)); }

/*
    void SetTrackingColor(uint aReMin=0,   uint aReMax=255, uint aGrMin=0,
                          uint aGrMax=255, uint aBlMin=0,   uint aBlMax=255);
    void SetImagerParams(int aContrast, int aBrightness,
                         int aAutogain, int aColormode);
    void SetContrast(int aC);
    void SetColorMode(int aM);
    void SetBrightness(int aB);
    void SetAutoGain(int aG);*/

};

class BumperProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_bumper_t *mDevice;

  public:

    BumperProxy(PlayerClient *aPc, uint aIndex=0);
    ~BumperProxy();

    uint GetCount() const { return GetVar(mDevice->bumper_count); };

    uint IsBumped(uint aIndex) const
      { return GetVar(mDevice->bumpers[aIndex]); };

    bool IsAnyBumped();

    void RequestBumperConfig();

    uint GetPoseCount() const { return GetVar(mDevice->pose_count); };

    player_bumper_define_t GetPose(uint aIndex) const
      { return GetVar(mDevice->poses[aIndex]); };

    bool operator [](uint aIndex) const
      { return IsBumped(aIndex); }

};

class CameraProxy : public ClientProxy
{

  private:

    virtual void Subscribe(uint aIndex);
    virtual void Unsubscribe();

    // libplayerc data structure
    playerc_camera_t *mDevice;

    std::string mPrefix;
    int mFrameNo;

  public:

    CameraProxy (PlayerClient *aPc, uint aIndex=0);

    virtual ~CameraProxy();

    void SaveFrame(const std::string aPrefix, uint aWidth=4);

    void Decompress();

    uint GetDepth() const { return GetVar(mDevice->bpp); };

    uint GetWidth() const { return GetVar(mDevice->width); };

    uint GetHeight() const { return GetVar(mDevice->height); };

    uint GetFormat() const { return GetVar(mDevice->format); };

    uint GetImageSize() const { return GetVar(mDevice->image_count); };

    void GetImage(uint8_t* aImage) const
      {
        return GetVarByRef(mDevice->image,
                           mDevice->image+GetVar(mDevice->image_count),
                           aImage);
      };

    uint GetCompression() const { return GetVar(mDevice->compression); };

};


class DioProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_dio_t *mDevice;

  public:
    DioProxy(PlayerClient *aPc, uint aIndex=0);
    ~DioProxy();

    uint GetCount() const { return GetVar(mDevice->count); };

    uint32_t GetDigin() const { return GetVar(mDevice->digin); };

    bool GetInput(uint aIndex) const;

    void SetOutput(uint aCount, uint32_t aDigout);

    uint operator [](uint aIndex) const
      { return GetInput(aIndex); }
};

// /**
// The @p EnergyProxy class is used to read from an @ref
// interface_energy device.
// */
// class EnergyProxy : public ClientProxy
// {
//   private:
//
//     void Subscribe(uint aIndex);
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_energy_t *mDevice;
//
// public:
//
//     EnergyProxy(PlayerClient *aPc, uint aIndex=0);
//     ~EnergyProxy();
//
//     /** These members give the current amount of energy stored [Joules] */
//     uint GetJoules() const { return GetVar(mDevice->joules); };
//     /** the amount of energy current being consumed [Watts] */
//     uint GetWatts() const { return GetVar(mDevice->watts); };
//     /** The charging flag is true if we are currently charging, else false. */
//     bool GetCharging() const { return GetVar(mDevice->charging); };
// };

class FiducialProxy : public ClientProxy
{
  private:
    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_fiducial_t *mDevice;

  public:
    FiducialProxy(PlayerClient *aPc, uint aIndex=0);
    ~FiducialProxy();

    uint GetCount() const { return GetVar(mDevice->fiducials_count); };

    player_fiducial_item_t GetFiducialItem(uint aIndex) const
      { return GetVar(mDevice->fiducials[aIndex]);};

    player_pose_t GetSensorPose() const
      { return GetVar(mDevice->fiducial_geom.pose);};

    player_bbox_t GetSensorSize() const
      { return GetVar(mDevice->fiducial_geom.size);};

    player_bbox_t GetFiducialSize() const
      { return GetVar(mDevice->fiducial_geom.fiducial_size);};

    void RequestGeometry();

    player_fiducial_item_t operator [](uint aIndex) const
      { return GetFiducialItem(aIndex); }
};

class GpsProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gps_t *mDevice;

  public:

    // Constructor
    GpsProxy(PlayerClient *aPc, uint aIndex=0);

    ~GpsProxy();

    double GetLatitude() const { return GetVar(mDevice->lat); };
    double GetLongitude() const { return GetVar(mDevice->lon); };

    double GetAltitude() const { return GetVar(mDevice->alt); };

    uint GetSatellites() const { return GetVar(mDevice->sat_count); };

    uint GetQuality() const { return GetVar(mDevice->quality); };

    double GetHdop() const { return GetVar(mDevice->hdop); };

    double GetVdop() const { return GetVar(mDevice->vdop); };

    double GetUtmEasting() const { return GetVar(mDevice->utm_e); };
    double GetUtmNorthing() const { return GetVar(mDevice->utm_n); };

    double GetTime() const { return GetVar(mDevice->utc_time); };

    double GetErrHorizontal() const { return GetVar(mDevice->err_horz); };
    double GetErrVertical() const { return GetVar(mDevice->err_vert); };
};

class Graphics2dProxy : public ClientProxy
{

  private:

    // Subscribe
    void Subscribe(uint aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_graphics2d_t *mDevice;

  public:
    // Constructor
    Graphics2dProxy(PlayerClient *aPc, uint aIndex=0);
    // Destructor
    ~Graphics2dProxy();

    void Color(player_color_t col);

    void Color(uint8_t red,  uint8_t green,  uint8_t blue,  uint8_t alpha);

    void Clear(void);

    void DrawPoints(player_point_2d_t pts[], int count);

    void DrawPolygon(player_point_2d_t pts[],
                     int count,
                     bool filled,
                     player_color_t fill_color);

    void DrawPolyline(player_point_2d_t pts[], int count);
};

class Graphics3dProxy : public ClientProxy
{

  private:

    // Subscribe
    void Subscribe(uint aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_graphics3d_t *mDevice;

  public:
    // Constructor
    Graphics3dProxy(PlayerClient *aPc, uint aIndex=0);
    // Destructor
    ~Graphics3dProxy();

    void Color(player_color_t col);

    void Color(uint8_t red,  uint8_t green,  uint8_t blue,  uint8_t alpha);

    void Clear(void);

    void Draw(player_graphics3d_draw_mode_t mode, player_point_3d_t pts[], int count);

};

class GripperProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gripper_t *mDevice;

  public:

    GripperProxy(PlayerClient *aPc, uint aIndex=0);
    ~GripperProxy();

    uint GetState() const { return GetVar(mDevice->state); };
    uint GetBeams() const { return GetVar(mDevice->beams); };
    uint GetOuterBreakBeam() const
      { return GetVar(mDevice->outer_break_beam); };
    uint GetInnerBreakBeam() const
      { return GetVar(mDevice->inner_break_beam); };
    uint GetPaddlesOpen() const
      { return GetVar(mDevice->paddles_open); };
    uint GetPaddlesClosed() const
      { return GetVar(mDevice->paddles_closed); };
    uint GetPaddlesMoving() const
      { return GetVar(mDevice->paddles_moving); };
    uint GetGripperError() const
      { return GetVar(mDevice->gripper_error); };
    uint GetLiftUp() const { return GetVar(mDevice->lift_up); };
    uint GetLiftDown() const { return GetVar(mDevice->lift_down); };
    uint GetLiftMoving() const { return GetVar(mDevice->lift_moving); };
    uint GetLiftError() const { return GetVar(mDevice->lift_error); };

    void SetGrip(uint8_t aCmd, uint8_t aArg=0);
};



class IrProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ir_t *mDevice;

  public:

    IrProxy(PlayerClient *aPc, uint aIndex=0);
    ~IrProxy();

    uint GetCount() const { return GetVar(mDevice->ranges.ranges_count); };
    double GetRange(uint aIndex) const
      { return GetVar(mDevice->ranges.ranges[aIndex]); };
    double GetVoltage(uint aIndex) const
      { return GetVar(mDevice->ranges.voltages[aIndex]); };
    uint GetPoseCount() const { return GetVar(mDevice->poses.poses_count); };
    player_pose_t GetPose(uint aIndex) const
      {return GetVar(mDevice->poses.poses[aIndex]);};

    void RequestGeom();

    double operator [](uint aIndex) const
      { return GetRange(aIndex); }

};

class LaserProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_laser_t *mDevice;

    // local storage of config
    double min_angle, max_angle, scan_res, range_res;
    bool intensity;

  public:

    LaserProxy(PlayerClient *aPc, uint aIndex=0);
    ~LaserProxy();

    uint GetCount() const { return GetVar(mDevice->scan_count); };
    
    double GetMaxRange() const { return GetVar(mDevice->max_range); };

    double GetScanRes() const { return GetVar(mDevice->scan_res); };

    double GetRangeRes() const { return GetVar(mDevice->range_res); };


    double GetMinAngle() const { return GetVar(mDevice->scan_start); };
    double GetMaxAngle() const
    {
      scoped_lock_t lock(mPc->mMutex);
      return mDevice->scan_start + mDevice->scan_count*mDevice->scan_res;
    };

    bool IntensityOn() const { return GetVar(mDevice->intensity_on); };

//    /// Scan data (polar): range (m) and bearing (radians)
//    double GetScan(uint aIndex) const
//      { return GetVar(mDevice->scan[aIndex]); };

    player_point_2d_t GetPoint(uint aIndex) const
      { return GetVar(mDevice->point[aIndex]); };


    double GetRange(uint aIndex) const
      { return GetVar(mDevice->ranges[aIndex]); };

    double GetBearing(uint aIndex) const
      { return GetVar(mDevice->scan[aIndex][1]); };


    int GetIntensity(uint aIndex) const
      { return GetVar(mDevice->intensity[aIndex]); };

    void Configure(double aMinAngle,
                   double aMaxAngle,
                   uint aScanRes,
                   uint aRangeRes,
                   bool aIntensity);

    void RequestConfigure();

    void RequestGeom();

    player_pose_t GetPose()
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);

      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pa = mDevice->pose[2];
      return(p);
    }
    
    player_pose_t GetRobotPose()
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);

      p.px = mDevice->robot_pose[0];
      p.py = mDevice->robot_pose[1];
      p.pa = mDevice->robot_pose[2];
      return(p);
    }

    player_bbox_t GetSize()
    {
      player_bbox_t b;
      scoped_lock_t lock(mPc->mMutex);

      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }
    
    double GetMinLeft() const
      { return GetVar(mDevice->min_left); };
    
    double GetMinRight() const
      { return GetVar(mDevice->min_right); };
           
    double MinLeft () const 
      { return GetMinLeft(); }

    double MinRight () const
      { return GetMinRight(); }

    double operator [] (uint index) const
      { return GetRange(index);}

};


class LimbProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

   // libplayerc data structure
    playerc_limb_t *mDevice;

  public:

    LimbProxy(PlayerClient *aPc, uint aIndex=0);
    ~LimbProxy();

    void RequestGeometry(void);

    void SetPowerConfig(bool aVal);
    void SetBrakesConfig(bool aVal);
    void SetSpeedConfig(float aSpeed);

    void MoveHome(void);
    void Stop(void);
    void SetPose(float aPX, float aPY, float aPZ,
                 float aAX, float aAY, float aAZ,
                 float aOX, float aOY, float aOZ);
    void SetPosition(float aX, float aY, float aZ);
    void VectorMove(float aX, float aY, float aZ, float aLength);

    player_limb_data_t GetData(void) const;
    player_limb_geom_req_t GetGeom(void) const;
};



class LocalizeProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_localize_t *mDevice;

  public:

    LocalizeProxy(PlayerClient *aPc, uint aIndex=0);
    ~LocalizeProxy();

    // @todo should these be in a player_pose_t?
    uint GetMapSizeX() const { return GetVar(mDevice->map_size_x); };
    uint GetMapSizeY() const { return GetVar(mDevice->map_size_y); };

    // @todo should these be in a player_pose_t?
    uint GetMapTileX() const { return GetVar(mDevice->map_tile_x); };
    uint GetMapTileY() const { return GetVar(mDevice->map_tile_y); };

    double GetMapScale() const { return GetVar(mDevice->map_scale); };

    // Map data (empty = -1, unknown = 0, occupied = +1)
    // is this still needed?  if so,
    //void GetMapCells(uint8_t* aCells) const
    //{
    //  return GetVarByRef(mDevice->map_cells,
    //                     mDevice->image+GetVar(mDevice->??map_cell_cout??),
    //                     aCells);
    //};

    uint GetPendingCount() const { return GetVar(mDevice->pending_count); };

    uint GetHypothCount() const { return GetVar(mDevice->hypoth_count); };

    player_localize_hypoth_t GetHypoth(uint aIndex) const
      { return GetVar(mDevice->hypoths[aIndex]); };

    int GetParticles()
      { return playerc_localize_get_particles(mDevice); }

    player_pose_t GetParticlePose(int index) const;

    void SetPose(double pose[3], double cov[3]);

    uint GetNumHypoths() const { return GetVar(mDevice->hypoth_count); };

    uint GetNumParticles() const { return GetVar(mDevice->num_particles); };
};


class LogProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_log_t *mDevice;

  public:
    LogProxy(PlayerClient *aPc, uint aIndex=0);

    ~LogProxy();

    int GetType() const { return GetVar(mDevice->type); };

    int GetState() const { return GetVar(mDevice->state); };

    void SetWriteState(int aState);

    void SetReadState(int aState);

    void Rewind();

    void SetFilename(const std::string aFilename);
};

class MapProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_map_t *mDevice;

  public:
    MapProxy(PlayerClient *aPc, uint aIndex=0);

    ~MapProxy();

    void RequestMap();

    int GetCellIndex(int x, int y) const
    { return y*GetWidth() + x; };

    int8_t GetCell(int x, int y) const
    { return GetVar(mDevice->cells[GetCellIndex(x,y)]); };

    double GetResolution() const { return GetVar(mDevice->resolution); };

    uint GetWidth() const { return GetVar(mDevice->width); };
    uint GetHeight() const { return GetVar(mDevice->height); };

    double GetOriginX() const { return GetVar(mDevice->origin[0]); };
    double GetOriginY() const { return GetVar(mDevice->origin[1]); };

    void GetMap(int8_t* aMap) const
    {
      return GetVarByRef(reinterpret_cast<int8_t*>(mDevice->cells),
                         reinterpret_cast<int8_t*>(mDevice->cells+GetWidth()*GetHeight()),
                         aMap);
    };
};

class OpaqueProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_opaque_t *mDevice;

  public:

    OpaqueProxy(PlayerClient *aPc, uint aIndex=0);
    ~OpaqueProxy();

    uint GetCount() const { return GetVar(mDevice->data_count); };

    void GetData(uint8_t* aDest) const
      {
        return GetVarByRef(mDevice->data,
                           mDevice->data+GetVar(mDevice->data_count),
                           aDest);
      };

    void SendCmd(player_opaque_data_t* aData);

};

class PlannerProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_planner_t *mDevice;

  public:

    PlannerProxy(PlayerClient *aPc, uint aIndex=0);
    ~PlannerProxy();

    void SetGoalPose(double aGx, double aGy, double aGa);

    void RequestWaypoints();

    void SetEnable(bool aEnable);

    uint GetPathValid() const { return GetVar(mDevice->path_valid); };

    uint GetPathDone() const { return GetVar(mDevice->path_done); };

    double GetPx() const { return GetVar(mDevice->px); };
    double GetPy() const { return GetVar(mDevice->py); };
    double GetPa() const { return GetVar(mDevice->pa); };

    player_pose_t GetPose() const
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->px;
      p.py = mDevice->py;
      p.pa = mDevice->pa;
      return(p);
    }

    double GetGx() const { return GetVar(mDevice->gx); };
    double GetGy() const { return GetVar(mDevice->gy); };
    double GetGa() const { return GetVar(mDevice->ga); };

    player_pose_t GetGoal() const
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->gx;
      p.py = mDevice->gy;
      p.pa = mDevice->ga;
      return(p);
    }

    double GetWx() const { return GetVar(mDevice->wx); };
    double GetWy() const { return GetVar(mDevice->wy); };
    double GetWa() const { return GetVar(mDevice->wa); };

    player_pose_t GetCurrentWaypoint() const
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->wx;
      p.py = mDevice->wy;
      p.pa = mDevice->wa;
      return(p);
    }

    double GetIx(int i) const;
    double GetIy(int i) const;
    double GetIa(int i) const;

    player_pose_t GetWaypoint(uint aIndex) const
    {
      assert(aIndex < GetWaypointCount());
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->waypoints[aIndex][0];
      p.py = mDevice->waypoints[aIndex][1];
      p.pa = mDevice->waypoints[aIndex][2];
      return(p);
    }

    int GetCurrentWaypointId() const
      { return GetVar(mDevice->curr_waypoint); };

    uint GetWaypointCount() const
      { return GetVar(mDevice->waypoint_count); };

    player_pose_t operator [](uint aIndex) const
      { return GetWaypoint(aIndex); }

};

class Position1dProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position1d_t *mDevice;

  public:

    Position1dProxy(PlayerClient *aPc, uint aIndex=0);
    ~Position1dProxy();

    void SetSpeed(double aVel);

    void GoTo(double aPos, double aVel);

    void RequestGeom();

    player_pose_t GetPose() const
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pa = mDevice->pose[2];
      return(p);
    }

    player_bbox_t GetSize() const
    {
      player_bbox_t b;
      scoped_lock_t lock(mPc->mMutex);
      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }

    void SetMotorEnable(bool enable);

    void SetOdometry(double aPos);

    void ResetOdometry() { SetOdometry(0); };

    //void SetSpeedPID(double kp, double ki, double kd);

    //void SetPositionPID(double kp, double ki, double kd);

    //void SetPositionSpeedProfile(double spd, double acc);

    double  GetPos() const { return GetVar(mDevice->pos); };

    double  GetVel() const { return GetVar(mDevice->vel); };

    bool GetStall() const { return GetVar(mDevice->stall); };

    uint8_t GetStatus() const { return GetVar(mDevice->status); };

    bool IsLimitMin() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_MIN)) > 0; };

    bool IsLimitCen() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_CEN)) > 0; };

    bool IsLimitMax() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_MAX)) > 0; };

    bool IsOverCurrent() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_OC)) > 0; };

    bool IsTrajComplete() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE)) > 0; };

    bool IsEnabled() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_ENABLED)) > 0; };

};

class Position2dProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position2d_t *mDevice;

  public:

    Position2dProxy(PlayerClient *aPc, uint aIndex=0);
    ~Position2dProxy();

    void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed);

    void SetSpeed(double aXSpeed, double aYawSpeed)
        { return SetSpeed(aXSpeed, 0, aYawSpeed);}

    void SetSpeed(player_pose_t vel)
        { return SetSpeed(vel.px, vel.py, vel.pa);}

    void SetVelHead(double aXSpeed, double aYSpeed, double aYawHead);

    void SetVelHead(double aXSpeed, double aYawHead)
        { return SetVelHead(aXSpeed, 0, aYawHead);}


    void GoTo(player_pose_t pos, player_pose_t vel);

    void GoTo(player_pose_t pos)
      {GoTo(pos,(player_pose_t) {0,0,0}); }

    void GoTo(double aX, double aY, double aYaw)
      {GoTo((player_pose_t) {aX,aY,aYaw},(player_pose_t) {0,0,0}); }

    void SetCarlike(double aXSpeed, double aDriveAngle);

    void RequestGeom();

    player_pose_t GetPose()
    {
      player_pose_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pa = mDevice->pose[2];
      return(p);
    }

    player_bbox_t GetSize()
    {
      player_bbox_t b;
      scoped_lock_t lock(mPc->mMutex);
      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }

    void SetMotorEnable(bool enable);

    // Select velocity control mode.
    //
    // For the the p2os_position driver, set @p mode to 0 for direct wheel
    // velocity control (default), or 1 for separate translational and
    // rotational control.
    //
    // For the reb_position driver: 0 is direct velocity control, 1 is for
    // velocity-based heading PD controller (uses DoDesiredHeading()).
    //void SelectVelocityControl(unsigned char mode);

    void ResetOdometry();

    //void SelectPositionMode(unsigned char mode);

    void SetOdometry(double aX, double aY, double aYaw);

    //void SetSpeedPID(double kp, double ki, double kd);

    //void SetPositionPID(double kp, double ki, double kd);

    //void SetPositionSpeedProfile(double spd, double acc);

    //
    // void DoStraightLine(double m);

    //
    //void DoRotation(double yawspeed);

    //
    //void DoDesiredHeading(double yaw, double xspeed, double yawspeed);

    //
    //void SetStatus(uint8_t cmd, uint16_t value);

    //
    //void PlatformShutdown();

    double  GetXPos() const { return GetVar(mDevice->px); };

    double  GetYPos() const { return GetVar(mDevice->py); };

    double GetYaw() const { return GetVar(mDevice->pa); };

    double  GetXSpeed() const { return GetVar(mDevice->vx); };

    double  GetYSpeed() const { return GetVar(mDevice->vy); };

    double  GetYawSpeed() const { return GetVar(mDevice->va); };

    bool GetStall() const { return GetVar(mDevice->stall); };

};

class Position3dProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position3d_t *mDevice;

  public:

    Position3dProxy(PlayerClient *aPc, uint aIndex=0);
    ~Position3dProxy();

    void SetSpeed(double aXSpeed, double aYSpeed, double aZSpeed,
                  double aRollSpeed, double aPitchSpeed, double aYawSpeed);

    void SetSpeed(double aXSpeed, double aYSpeed,
                  double aZSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed,aYSpeed,aZSpeed,0,0,aYawSpeed); }

    void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed, aYSpeed, 0, 0, 0, aYawSpeed); }

    void SetSpeed(double aXSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed,0,0,0,0,aYawSpeed);}

    void SetSpeed(player_pose3d_t vel)
      { SetSpeed(vel.px,vel.py,vel.pz,vel.proll,vel.ppitch,vel.pyaw);}


    void GoTo(player_pose3d_t aPos, player_pose3d_t aVel);

    void GoTo(player_pose3d_t aPos)
      { GoTo(aPos, (player_pose3d_t) {0,0,0,0,0,0}); }


    void GoTo(double aX, double aY, double aZ,
              double aRoll, double aPitch, double aYaw)
      { GoTo((player_pose3d_t) {aX,aY,aZ,aRoll,aPitch,aYaw},
              (player_pose3d_t) {0,0,0,0,0,0});
      }

    void SetMotorEnable(bool aEnable);

    void SelectVelocityControl(int aMode);

    void ResetOdometry();

    void SetOdometry(double aX, double aY, double aZ,
                     double aRoll, double aPitch, double aYaw);

    // Select position mode
    // Set @p mode for 0 for velocity mode, 1 for position mode.
    //void SelectPositionMode(unsigned char mode);

    //
    //void SetSpeedPID(double kp, double ki, double kd);

    //
    //void SetPositionPID(double kp, double ki, double kd);

    // Sets the ramp profile for position based control
    // spd rad/s, acc rad/s/s
    //void SetPositionSpeedProfile(double spd, double acc);

    double  GetXPos() const { return GetVar(mDevice->pos_x); };

    double  GetYPos() const { return GetVar(mDevice->pos_y); };

    double  GetZPos() const { return GetVar(mDevice->pos_z); };

    double  GetRoll() const { return GetVar(mDevice->pos_roll); };

    double  GetPitch() const { return GetVar(mDevice->pos_pitch); };

    double  GetYaw() const { return GetVar(mDevice->pos_yaw); };

    double  GetXSpeed() const { return GetVar(mDevice->vel_x); };

    double  GetYSpeed() const { return GetVar(mDevice->vel_y); };

    double  GetZSpeed() const { return GetVar(mDevice->vel_z); };

    double  GetRollSpeed() const { return GetVar(mDevice->vel_roll); };

    double  GetPitchSpeed() const { return GetVar(mDevice->vel_pitch); };

    double  GetYawSpeed() const { return GetVar(mDevice->vel_yaw); };

    bool GetStall () const { return GetVar(mDevice->stall); };
};
class PowerProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_power_t *mDevice;

  public:
    PowerProxy(PlayerClient *aPc, uint aIndex=0);
    ~PowerProxy();

    double GetCharge() const { return GetVar(mDevice->charge); };

};

class PtzProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ptz_t *mDevice;

  public:
    PtzProxy(PlayerClient *aPc, uint aIndex=0);
    // destructor
    ~PtzProxy();

  public:

    void SetCam(double aPan, double aTilt, double aZoom);

    void SetSpeed(double aPanSpeed=0, double aTiltSpeed=0, double aZoomSpeed=0);

    void SelectControlMode(uint aMode);

    double GetPan() const { return GetVar(mDevice->pan); };
    double GetTilt() const { return GetVar(mDevice->tilt); };
    double GetZoom() const { return GetVar(mDevice->zoom); };

};

class RFIDProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_rfid_t *mDevice;

  public:
    RFIDProxy(PlayerClient *aPc, uint aIndex=0);
    ~RFIDProxy();

    uint GetTagsCount() const { return GetVar(mDevice->tags_count); };
    playerc_rfidtag_t GetRFIDTag(uint aIndex) const
      { return GetVar(mDevice->tags[aIndex]);};

    playerc_rfidtag_t operator [](uint aIndex) const
      { return(GetRFIDTag(aIndex)); }
};

class SimulationProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_simulation_t *mDevice;

  public:
    SimulationProxy(PlayerClient *aPc, uint aIndex=0);
    ~SimulationProxy();

    void SetPose2d(char* identifier, double x, double y, double a);

    void GetPose2d(char* identifier, double& x, double& y, double& a);

    void SetProperty(char * name, char * property, int value);
    
    void SetProperty(char * name, char * property, double value);
    
    void SetProperty(char * name, char * property, char * value);
};


class SonarProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_sonar_t *mDevice;

  public:
    SonarProxy(PlayerClient *aPc, uint aIndex=0);
    ~SonarProxy();

    uint GetCount() const { return GetVar(mDevice->scan_count); };

    double GetScan(uint aIndex) const
      { return GetVar(mDevice->scan[aIndex]); };
    double operator [] (uint aIndex) const { return GetScan(aIndex); }

    uint GetPoseCount() const { return GetVar(mDevice->pose_count); };

    player_pose_t GetPose(uint aIndex) const
      { return GetVar(mDevice->poses[aIndex]); };

    // Enable/disable the sonars.
    // Set @p state to 1 to enable, 0 to disable.
    // Note that when sonars are disabled the client will still receive sonar
    // data, but the ranges will always be the last value read from the sonars
    // before they were disabled.
    //void SetEnable(bool aEnable);

    void RequestGeom();
};

// /**
// The @p SoundProxy class is used to control a @ref interface_sound
// device, which allows you to play pre-recorded sound files on a robot.
// */
// class SoundProxy : public ClientProxy
// {
//
//   private:
//
//     void Subscribe(uint aIndex);
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_sound_t *mDevice;
//
//   public:
//     // Constructor
//     SoundProxy(PlayerClient *aPc, uint aIndex=0);
//
//     ~SoundProxy();
//
//     /** Play the sound indicated by the index. */
//     void Play(int aIndex);
// };

class SpeechProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_speech_t *mDevice;

  public:
    SpeechProxy(PlayerClient *aPc, uint aIndex=0);
    ~SpeechProxy();

    void Say(std::string aStr);
};

class SpeechRecognitionProxy : public ClientProxy
{
   void Subscribe(uint aIndex);
   void Unsubscribe();

   playerc_speechrecognition_t *mDevice;
  public:
   SpeechRecognitionProxy(PlayerClient *aPc, uint aIndex=0);
   ~SpeechRecognitionProxy();
   std::string GetWord(uint aWord) const{ 
     scoped_lock_t lock(mPc->mMutex);
     return std::string(mDevice->words[aWord]); 
   }

   uint GetCount(void) const { return GetVar(mDevice->wordCount); }

   std::string operator [](uint aWord) { return(GetWord(aWord)); }
};

// /**
// The @p WaveformProxy class is used to read raw digital waveforms from
// a @ref interface_waveform device.  */
// class WaveformProxy : public ClientProxy
// {
//
//   private:
//
//     void Subscribe(uint aIndex);
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_waveform_t *mDevice;
//
//   public:
//     /// Constructor
//     WaveformProxy(PlayerClient *aPc, uint aIndex=0);
//
//     /// Destructor
//     ~WaveformProxy();
//
//     /// How many samples?
//     uint GetCount() const { return GetVar(mDevice->data_count); };
//
//     /// sample rate in bits per second
//     uint GetBitRate() const { return GetVar(mDevice->rate); };
//
//     /// sample depth in bits
//     uint GetDepth() const { return GetVar(mDevice->depth); };
//
//     /// the data is buffered here for playback
//     void GetImage(uint8_t* aBuffer) const
//     {
//       return GetVarByRef(mDevice->data,
//                          mDevice->data+GetCount(),
//                          aBuffer);
//     };
//
//     // dsp file descriptor
//     //uint GetFd() const { return GetVar(mDevice->fd); };
//
//     /// set up the DSP to the current bitrate and depth
//     void ConfigureDSP(uint aBitRate, uint aDepth);
//
//     /// open the sound device
//     void OpenDSPforWrite();
//
//     /// Play the waveform through the DSP
//     void Play();
// };

class WiFiProxy: public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_wifi_t *mDevice;

  public:
    WiFiProxy(PlayerClient *aPc, uint aIndex=0);
    ~WiFiProxy();

                         int GetLinkCount(){ return mDevice->link_count; };
                         char* GetOwnIP(){ return mDevice->ip; };

                         char* GetLinkIP(int index) { return (char*) mDevice->links[index].ip; };
                         char* GetLinkMAC(int index) { return (char*) mDevice->links[index].mac; };
                         char* GetLinkESSID(int index) { return (char*)mDevice->links[index].essid; };
                         double GetLinkFreq(int index) {return mDevice->links[index].freq;};
                         int     GetLinkMode(int index) { return mDevice->links[index].mode; };
                         int     GetLinkEncrypt(int index) {return mDevice->links[index].encrypt; };
                         int   GetLinkQuality(int index) { return mDevice->links[index].qual; };
                         int     GetLinkLevel(int index) {return mDevice->links[index].level; };
                         int     GetLinkNoise(int index) {return mDevice->links[index].noise; } ;                

                        //player_wifi_link_t
//     int GetLinkQuality(char/// ip = NULL);
//     int GetLevel(char/// ip = NULL);
//     int GetLeveldBm(char/// ip = NULL) { return GetLevel(ip) - 0x100; }
//     int GetNoise(char/// ip = NULL);
//     int GetNoisedBm(char/// ip = NULL) { return GetNoise(ip) - 0x100; }
//
//     uint16_t GetMaxLinkQuality() { return maxqual; }
//     uint8_t GetMode() { return op_mode; }
//
//     int GetBitrate();
//
//     char/// GetMAC(char *buf, int len);
//
//     char/// GetIP(char *buf, int len);
//     char/// GetAP(char *buf, int len);
//
//     int AddSpyHost(char *address);
//     int RemoveSpyHost(char *address);
//
//   private:
//     int GetLinkIndex(char *ip);
//
//     /// The current wifi data.
//     int link_count;
//     player_wifi_link_t links[PLAYER_WIFI_MAX_LINKS];
//     uint32_t throughput;
//     uint8_t op_mode;
//     int32_t bitrate;
//     uint16_t qual_type, maxqual, maxlevel, maxnoise;
//
//     char access_point[32];
};

class WSNProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_wsn_t *mDevice;

  public:
    WSNProxy(PlayerClient *aPc, uint aIndex=0);
    ~WSNProxy();

    uint GetNodeType    () const { return GetVar(mDevice->node_type);      };
    uint GetNodeID      () const { return GetVar(mDevice->node_id);        };
    uint GetNodeParentID() const { return GetVar(mDevice->node_parent_id); };

    player_wsn_node_data_t
       GetNodeDataPacket() const { return GetVar(mDevice->data_packet);    };

    void SetDevState(int nodeID, int groupID, int devNr, int value);
    void Power(int nodeID, int groupID, int value);
    void DataType(int value);
    void DataFreq(int nodeID, int groupID, float frequency);
};

}

namespace std
{
  std::ostream& operator << (std::ostream& os, const player_point_2d_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose3d_t& c);
  std::ostream& operator << (std::ostream& os, const player_bbox_t& c);
  std::ostream& operator << (std::ostream& os, const player_segment_t& c);
  std::ostream& operator << (std::ostream& os, const playerc_device_info_t& c);

  std::ostream& operator << (std::ostream& os, const PlayerCc::ClientProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::ActArrayProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::AioProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::AudioDspProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::AudioMixerProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::BlinkenLightProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::BlobfinderProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::BumperProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::CameraProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::DioProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::EnergyProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::FiducialProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::GpsProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::GripperProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::IrProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LaserProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LimbProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LocalizeProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LogProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::MapProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::OpaqueProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PlannerProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position1dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position2dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position3dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PowerProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PtzProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SimulationProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SonarProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechRecognitionProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::WafeformProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::WiFiProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::RFIDProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::WSNProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::TruthProxy& c);
}

#endif

---

Last updated 12 September 2005 21:38:45