ArClientFileUtils.h

Go to the documentation of this file.

/*
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 ARCLIENTFILEUTILS_H
#define ARCLIENTFILEUTILS_H

#include "Aria.h"
#include "ArClientBase.h"

class ArClientFileListerItem
{
public:
  ArClientFileListerItem(const char *name, time_t atime, time_t mtime,
                         ArTypes::UByte4 size)
    { myName = name; myATime = atime; myMTime = mtime; mySize = size; }
  ArClientFileListerItem(const ArClientFileListerItem &item)
    { myName = item.myName; myATime = item.myATime; myMTime = item.myMTime; 
    mySize = item.mySize; }
  AREXPORT ArClientFileListerItem &operator=(const 
                                             ArClientFileListerItem &item)
    {
      if (this != &item) 
      {
        myName = item.myName; myATime = item.myATime; myMTime = item.myMTime; 
        mySize = item.mySize; 
      }
      return *this;
    }
  virtual ~ArClientFileListerItem() {}
  const char *getName(void) const { return myName.c_str(); }
  time_t getLastAccessedTime(void) const { return myATime; }
  time_t getLastModifiedTime(void) const { return myMTime; }
  ArTypes::UByte4 getSize(void) const { return mySize; }
protected:
  std::string myName;
  time_t myATime;
  time_t myMTime;
  ArTypes::UByte4 mySize; 
};


class ArClientFileLister
{
public:
  AREXPORT ArClientFileLister(ArClientBase *client);
  AREXPORT virtual ~ArClientFileLister();
  AREXPORT bool isAvailable(void);      
  AREXPORT void changeToTopDir(void);
  AREXPORT void changeToDir(const char *dir);
  AREXPORT void upOneDir(void);
  AREXPORT void changeToAbsDir(const char *dir);
  AREXPORT const char *getCurrentDir(void) const;
  AREXPORT std::list<ArClientFileListerItem> getDirectories(void) const;
  AREXPORT std::list<ArClientFileListerItem> getFiles(void) const;
  AREXPORT void addUpdatedCallback(ArFunctor1<int> *functor, 
                                   ArListPos::Pos position = ArListPos::LAST);
  AREXPORT void remUpdatedCallback(ArFunctor1<int> *functor);
  AREXPORT ArTime getLastUpdated(void);
  AREXPORT ArTime getLastRequested(void);
  AREXPORT void log(bool withTimes);
protected:
  AREXPORT void netGetDirListing(ArNetPacket *packet);
  AREXPORT void callUpdatedCallbacks(int val);
  AREXPORT void logList(
          std::list<ArClientFileListerItem> *logThis,
          bool withTimes);
  ArMutex myDataMutex;
  ArMutex myCallbackMutex;
  ArClientBase *myClient;
  char myCurrentDir[2048];
  char myWaitingForDir[2048];
  ArTime myLastRequested;
  ArTime myLastUpdated;
  std::list<ArClientFileListerItem> myDirectories;
  std::list<ArClientFileListerItem> myFiles;
  std::list<ArFunctor1<int> *> myUpdatedCallbacks;
  ArFunctor1C<ArClientFileLister, ArNetPacket *> myGetDirListingCB;
};



class ArClientFileToClient
{
public:
  AREXPORT ArClientFileToClient(ArClientBase *client);
  AREXPORT virtual ~ArClientFileToClient();
  AREXPORT bool isAvailable(void);      
  AREXPORT bool getFileFromDirectory(const char *directory, 
                                     const char *fileName, 
                                     const char *clientFileName);
  AREXPORT void cancelGet(void);
  AREXPORT bool isWaitingForFile(void);
  AREXPORT const char *getDirectory(void);
  AREXPORT const char *getFileName(void);
  AREXPORT const char *getClientFileName(void);
  AREXPORT void addFileReceivedCallback(ArFunctor1<int> *functor, 
                                   ArListPos::Pos position = ArListPos::LAST);
  AREXPORT void remFileReceivedCallback(ArFunctor1<int> *functor);
  AREXPORT ArTime getLastReceived(void);
  AREXPORT ArTime getLastRequested(void);
protected:
  AREXPORT void netGetFile(ArNetPacket *packet);
  AREXPORT void callFileReceivedCallbacks(int val);
  ArMutex myDataMutex;
  ArMutex myCallbackMutex;
  ArClientBase *myClient;
  bool myIsWaitingForFile;
  std::string myDirectory;
  std::string myFileName;
  std::string myWholeFileName;
  std::string myClientFileName;
  FILE *myFile;
  ArTime myLastRequested;
  ArTime myLastReceived;
  std::list<ArFunctor1<int> *> myFileReceivedCallbacks;
  ArFunctor1C<ArClientFileToClient, ArNetPacket *> myGetFileCB;
};


class ArClientFileFromClient
{
public:
  AREXPORT ArClientFileFromClient(ArClientBase *client);
  AREXPORT virtual ~ArClientFileFromClient();
  AREXPORT bool isAvailable(void);      
  AREXPORT bool isAvailableSlow(void);      
  AREXPORT bool isAvailableFast(void);      
  enum SendSpeed 
  {
    SPEED_AUTO, 
    SPEED_FAST, 
    SPEED_SLOW 
  };
  AREXPORT bool putFileToDirectory(const char *directory, 
                                   const char *fileName, 
                                   const char *clientFileName,
                                   SendSpeed sendSpeed = SPEED_AUTO);
  AREXPORT void cancelPut(void);
  AREXPORT bool isWaitingForReturn(void);
  AREXPORT const char *getDirectory(void);
  AREXPORT const char *getFileName(void);
  AREXPORT const char *getClientFileName(void);
  AREXPORT void addFileSentCallback(ArFunctor1<int> *functor, 
                                   ArListPos::Pos position = ArListPos::LAST);
  AREXPORT void remFileSentCallback(ArFunctor1<int> *functor);
  AREXPORT ArTime getLastCompletedSend(void);
  AREXPORT ArTime getLastStartedSend(void);
protected:
  AREXPORT void netPutFile(ArNetPacket *packet);
  AREXPORT void callFileSentCallbacks(int val);
  ArMutex myDataMutex;
  ArMutex myCallbackMutex;
  ArClientBase *myClient;
  bool myIsWaitingForReturn;
  bool myInterleaved;
  std::string myCommandName;
  std::string myDirectory;
  std::string myFileName;
  std::string myWholeFileName;
  std::string myClientFileName;
  
  bool myReadyForNextPacket;
  FILE *myFile;
  ArTime myLastStartedSend;
  ArTime myLastCompletedSend;
  std::list<ArFunctor1<int> *> myFileSentCallbacks;
  ArFunctor1C<ArClientFileFromClient, ArNetPacket *> myPutFileCB;
};



class ArClientDeleteFileOnServer
{
public:
  AREXPORT ArClientDeleteFileOnServer(ArClientBase *client);
  AREXPORT virtual ~ArClientDeleteFileOnServer();
  AREXPORT bool isAvailable(void);      
  AREXPORT bool deleteFileFromDirectory(const char *directory, 
                                        const char *fileName);
  AREXPORT bool isWaitingForReturn(void);
  AREXPORT const char *getDirectory(void);
  AREXPORT const char *getFileName(void);
  AREXPORT void addFileDeletedCallback(ArFunctor1<int> *functor, 
                                   ArListPos::Pos position = ArListPos::LAST);
  AREXPORT void remFileDeletedCallback(ArFunctor1<int> *functor);
  AREXPORT ArTime getLastCompletedSend(void);
  AREXPORT ArTime getLastStartedSend(void);
protected:
  AREXPORT void netDeleteFile(ArNetPacket *packet);
  AREXPORT void callFileDeletedCallbacks(int val);
  ArMutex myDataMutex;
  ArMutex myCallbackMutex;
  ArClientBase *myClient;
  bool myIsWaitingForReturn;
  std::string myDirectory;
  std::string myFileName;
  std::string myWholeFileName;
  FILE *myFile;
  ArTime myLastStartedSend;
  ArTime myLastCompletedSend;
  std::list<ArFunctor1<int> *> myFileDeletedCallbacks;
  ArFunctor1C<ArClientDeleteFileOnServer, ArNetPacket *> myDeleteFileCB;
};

#endif //ARCLIENTFILEUTILS_H

---