ArCameraCollection.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARCAMERACOLLECTION_H
#define ARCAMERACOLLECTION_H

#include <list>
#include <map>
#include <string>

#include "ArConfigArg.h"
#include "ArFunctor.h"
#include "ArMutex.h"

class ArCameraCollectionItem;
class ArCameraParameterSource;


class ArCameraCollection
{
public:
    
  AREXPORT ArCameraCollection();

    AREXPORT virtual ~ArCameraCollection();
    
  // ---------------------------------------------------------------------------


  AREXPORT virtual bool addCamera(const char *cameraName,
                                  const char *cameraType,
                                  const char *displayName,
                                  const char *displayType);


  AREXPORT virtual bool removeCamera(const char *cameraName);


  AREXPORT virtual bool addCameraCommand(const char *cameraName,
                                         const char *command,
                                         const char *cameraCommandName,
                                         int requestInterval = -1);



  AREXPORT virtual bool removeCameraCommand(const char *cameraName,
                                            const char *command);



  AREXPORT virtual bool addParameter(const char *cameraName,
                                     ArCameraParameterSource *source,
                                     const ArConfigArg &param);



  AREXPORT virtual bool removeParameter(const char *cameraName,
                                        const char *paramName);

  // ---------------------------------------------------------------------------


  AREXPORT virtual void getCameraNames(std::list<std::string> &outList);



  AREXPORT virtual const char *getCameraType(const char *cameraName);


  AREXPORT virtual const char *getDisplayName(const char *cameraName);


  AREXPORT virtual const char *getDisplayType(const char *cameraName);

 // ---------------------------------------------------------------------------


  AREXPORT virtual void getCameraCommands(const char *cameraName,
                                          std::list<std::string> &outList);


  AREXPORT virtual const char *getCommandName(const char *cameraName,
                                              const char *command);


  AREXPORT virtual int getRequestInterval(const char *cameraName,
                                          const char *command);

  // ---------------------------------------------------------------------------


  AREXPORT virtual void getParameterNames(const char *cameraName,
                                          std::list<std::string> &outList);


  AREXPORT virtual bool getParameter(const char *cameraName,
                                     const char *parameterName,
                                     ArConfigArg &paramOut);
  

  AREXPORT virtual bool setParameter(const char *cameraName,
                                     const ArConfigArg &param);
 
  // ---------------------------------------------------------------------------

  AREXPORT virtual bool exists(const char *cameraName);

  AREXPORT virtual bool exists(const char *cameraName,
                               const char *command);

  AREXPORT virtual bool parameterExists(const char *cameraName,
                        const char *paramName);

  // ---------------------------------------------------------------------------


  AREXPORT virtual bool addModifiedCB(ArFunctor *functor,
                                      ArListPos::Pos position = ArListPos::LAST);


  AREXPORT virtual bool removeModifiedCB(ArFunctor *functor);



  AREXPORT virtual void startUpdate();


  AREXPORT virtual void endUpdate();


  // ---------------------------------------------------------------------------

  AREXPORT int lock() {
    return (myMutex.lock()); 
  }

  AREXPORT int tryLock() {
    return(myMutex.tryLock());
  }

  AREXPORT int unlock() {
    return(myMutex.unlock());
  }


// -----------------------------------------------------------------------------
protected:

  struct CommandInfo {

    std::string myCommand;
    std::string myCameraCommandName;
    int myRequestInterval;

    CommandInfo();
    ~CommandInfo();

  }; // end struct CommandInfo


  struct ParamInfo {

    ArCameraParameterSource *mySource;
    ArConfigArg myParam;
  
    ParamInfo();
    ~ParamInfo();

  }; // end struct ParamInfo


  struct CameraInfo {

    std::string myCameraName;
    std::string myCameraType;
    std::string myDisplayName;
    std::string myDisplayType;
    std::map<std::string, CommandInfo*> myCommandToInfoMap;
    std::map<std::string, ParamInfo*> myParamToInfoMap;

    CameraInfo();
    ~CameraInfo();

  }; // end struct CameraInfo


  CameraInfo *findCameraInfo(const char *cameraName);

  CommandInfo *findCommandInfo(const char *cameraName,
                               const char *commandName);

  ParamInfo *findParamInfo(const char *cameraName,
                           const char *paramName);

  void setModified();

  void notifyModifiedListeners();

private:
  ArCameraCollection(const ArCameraCollection &);
    ArCameraCollection &operator=(const ArCameraCollection &);

protected:

  ArMutex myMutex;
  std::map<std::string, CameraInfo*> myCameraToInfoMap;
  bool myIsUpdatesEnabled;
  bool myIsModified;
  std::list<ArFunctor *> myModifiedCBList;

}; // end class ArCameraCollection

// -----------------------------------------------------------------------------


class ArCameraCollectionItem 
{
public:

  AREXPORT ArCameraCollectionItem() {};
  AREXPORT virtual ~ArCameraCollectionItem() {};

  AREXPORT virtual const char *getCameraName() = 0;

  AREXPORT virtual void addToCameraCollection(ArCameraCollection &collection) = 0;

}; // end class ArCameraCollectionItem

// -----------------------------------------------------------------------------


class ArCameraParameterSource : public ArCameraCollectionItem
{
public:

  AREXPORT ArCameraParameterSource() {};
  AREXPORT ~ArCameraParameterSource() {};

  AREXPORT virtual bool getParameter(const char *paramName,
                                     ArConfigArg &paramOut) = 0;

  AREXPORT virtual bool setParameter(const ArConfigArg &param) = 0;

}; // end class ArCameraParameterSource


#endif // ARCAMERACOLLECTION_H

---