ftpfilestate.h

自己改写的在WINCE上开发用的EVC++的FTP操作示例工程,希望能给相关人士提供帮助.

////////////////////////////////////////////////////////////////////////////////
// 
// Copyright (c) 2004 Thomas Oswald
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
//
////////////////////////////////////////////////////////////////////////////////

#ifndef INC_FTPFILESTATE_H
#define INC_FTPFILESTATE_H

//#include <string>
#include <vector>
#include "rc_smart_ptr.h"
#include "Definements.h"
#include "StringA.h"

namespace nsFTP
{
	class CFTPFileStatus;
	typedef nsSP::RCIPtr<CFTPFileStatus>   TSpFTPFileStatus;
	typedef std::vector<TSpFTPFileStatus>  TSpFTPFileStatusVector;
	
	/// Holds status information about a file on the ftp server.
	class CFTPFileStatus
	{
	public:
		enum T_enSizeType 
		{
			stUnknown,
				stBinary,        ///< size is the number of octets in TYPE I
				stASCII,         ///< size is the number of octets in TYPE A
		};
		
		/// When a time zone is unknown, it is assumed to be GMT. You may want
		/// to use localtime() for LOCAL times, along with an indication that the
		/// time is correct in the local time zone, and gmtime() for REMOTE* times.
		enum T_enMTimeType 
		{
			mttUnknown,
				mttLocal,        ///< time is correct
				mttRemoteMinute, ///< time zone and secs are unknown
				mttRemoteDay,    ///< time zone and time of day are unknown
		};
		
		enum T_enIDType 
		{
			idUnknown,
				idFull,          ///< unique identifier for files on this FTP server
		};
		
		friend class CFTPListParse;
		
	public:
		CFTPFileStatus();
		CFTPFileStatus(const CFTPFileStatus& src);
		~CFTPFileStatus();
		
		CFTPFileStatus& operator=(const CFTPFileStatus& rhs);
		bool operator==(const CFTPFileStatus& rhs) const;
		bool operator!=(const CFTPFileStatus& rhs) const;
		
	public:
		void Reset();
		
		const CStringA& Name()           const { return m_strName;                };
		const CStringA& Path()           const { return m_strPath;                };
		bool           IsCwdPossible()  const { return m_fTryCwd;                };
		bool           IsRetrPossible() const { return m_fTryRetr;               };
		T_enSizeType   SizeType()       const { return m_enSizeType;             };
		long           Size()           const { return m_lSize;                  };
		T_enMTimeType  MTimeType()      const { return m_enModificationTimeType; };
		time_t         MTime()          const { return m_mtime;                  };
		const CStringA& Attributes()     const { return m_strAttributes;          };
		const CStringA& UID()            const { return m_strUID;                 };
		const CStringA& GID()            const { return m_strGID;                 };
		const CStringA& Link()           const { return m_strLink;                };
		T_enIDType     IDType()         const { return m_enIDType;               };
		const CStringA& ID()             const { return m_strID;                  };
		bool           IsDot()          const { return m_strName==_T(".") || m_strName==_T(".."); };
#ifdef _DEBUG
		const CStringA& MTimeStr()       const { return m_strMTime;               };
#endif
		
		CStringA&       Name()         { return m_strName;                };
		CStringA&       Path()         { return m_strPath;                };
		bool&          CwdPossible()  { return m_fTryCwd;                };
		bool&          RetrPossible() { return m_fTryRetr;               };
		T_enSizeType&  SizeType()     { return m_enSizeType;             };
		long&          Size()         { return m_lSize;                  };
		T_enMTimeType& MTimeType()    { return m_enModificationTimeType; };
		time_t&        MTime()        { return m_mtime;                  };
		CStringA&       Attributes()   { return m_strAttributes;          };
		CStringA&       UID()          { return m_strUID;                 };
		CStringA&       GID()          { return m_strGID;                 };
		CStringA&       Link()         { return m_strLink;                };
		T_enIDType&    IDType()       { return m_enIDType;               };
		CStringA&       ID()           { return m_strID;                  };
#ifdef _DEBUG
		CStringA&       MTimeStr()     { return m_strMTime;               };
#endif
		
	private:
		CStringA        m_strName;
		CStringA        m_strPath;
		bool           m_fTryCwd;                 ///< false if cwd is definitely pointless, true otherwise
		bool           m_fTryRetr;                ///< false if RETR is definitely pointless, true otherwise 
		T_enSizeType   m_enSizeType;
		long           m_lSize;                   ///< number of octets
		T_enMTimeType  m_enModificationTimeType;
		time_t         m_mtime;                   ///< modification time
		CStringA        m_strAttributes;           ///< file attributes
		CStringA        m_strUID;                  ///< user identifier (owner of file)
		CStringA        m_strGID;                  ///< group identifier
		CStringA        m_strLink;                 ///< number of links to file
		T_enIDType     m_enIDType;                ///< identifier type
		CStringA        m_strID;                   ///< identifier
#ifdef _DEBUG
		CStringA        m_strMTime;                ///< for debug only
#endif
	};
	
	/// Baseclass for functionobjects
	class CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const = 0;
	};
	
	/// Order by name.
	class CName : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->Name().GetString(), y->Name().GetString()) > 0);
		}
	};
	
	/// Order by size.
	class CSizeT : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return x->Size() > y->Size();
		}
	};
	
	/// Order by modification date.
	class CMTime : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return x->MTime() > y->MTime();
		}
	};
	
	/// Order by attributes.
	class CAttributes : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->Attributes().GetString(), y->Attributes().GetString()) > 0);
		}
	};
	
	/// Order by user id.
	class CUID : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->UID().GetString(), y->UID().GetString()) > 0);
		}
	};
	
	/// Order by group id.
	class CGID : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->GID().GetString(), y->GID().GetString()) > 0);
		}
	};
	
	/// Order by link.
	class CLink : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->Link().GetString(), y->Link().GetString()) > 0);
		}
	};
	
	/// Order by id.
	class CID : public CSortCriteria
	{
	public:
		virtual bool Compare(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		{
			return (strcmp(x->ID().GetString(), y->ID().GetString()) > 0);
		}
	};
	
	/// Function object for sorting the filelists
	class CFTPFileStatusContainerSort
	{
		const CSortCriteria& m_rSortBase;  ///< sortkey
		const bool           m_fAscending; ///< sort order
		const bool           m_fDirFirst;  ///< if true, then directories are before the files
		///< if false, directories and files are mixed up
		
	public:
		CFTPFileStatusContainerSort(const CSortCriteria& rSortBase, bool fAscending, bool fDirFirst) :
		  m_rSortBase(rSortBase),
			  m_fAscending(fAscending),
			  m_fDirFirst(fDirFirst)
		  {};
		  
		  /// entry function for STL sort algorithm
		  bool operator()(const TSpFTPFileStatus& x, const TSpFTPFileStatus& y) const
		  {
			  if( m_fDirFirst )
			  {
				  if( x->Name().GetLength()<3 || y->Name().GetLength()<3 )
				  {
					  if( x->Name().GetAt(0)=='.' && y->Name().GetAt(0)=='.' )
						  return m_fAscending && x->Name()==".";
					  else if( x->Name().GetAt(0)=='.' )
						  return m_fAscending && true;
					  else if( y->Name().GetAt(0)=='.' )
						  return m_fAscending && false;
				  }
				  
				  if( x->IsCwdPossible() != y->IsCwdPossible() )
				  {
					  if( x->IsCwdPossible() && !y->IsCwdPossible() )
						  return true;
					  return false;
				  }
			  }
			  
			  if( m_fAscending )
				  return !m_rSortBase.Compare(x, y);
			  else
				  return m_rSortBase.Compare(x, y);
		  }
	};
	
}
#endif // INC_FTPFILESTATE_H