ScanDelCopy

/********************************************************************
 created: 2011/05/07
 created: 7:5:2011   9:27
 filename:  g:/20110221文件整理/源码/UI/UI_20110447/Scan/Scan/ScanFolder.h
 file path: g:/20110221文件整理/源码/UI/UI_20110447/Scan/Scan
 file base: ScanFolder
 file ext: h
 author:  Clark
 
 purpose: Scan folder
 Use case:
    DelListInfo objScanInfo;
    ProcessFolder objProcessFolder;
    objProcessFolder.Scan(&objScanInfo,_T("//ResidentFlash//2"));
*********************************************************************/
#pragma once
#include "FolderInfo.h"

 

class FolderInfo;

template<class Item>
class ScanFolder
{
public:
 virtual ~ScanFolder(void);
 virtual BOOL Scan(Item* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression = _T("//*")); //扫描完毕返回真

protected:
 ScanFolder();
 BOOL   DoScan(Item* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression = _T("//*"), TCHAR* SubFolder = _T(""));
 virtual BOOL Init(Item* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression = _T("//*")) = 0;
 virtual BOOL ProcessItem(Item* pItem, TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd) = 0;
 void   SetOrder(BOOL bIsPostorder);

private:
 BOOL m_bIsPostorder;
};

class ProcessFolder: public ScanFolder<FolderInfo>
{//支持实时获得数据
public:
 ProcessFolder();
 virtual ~ProcessFolder(void);

protected:
 virtual BOOL Init(FolderInfo* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression = _T("//*"));
 virtual BOOL ProcessItem(FolderInfo* pItem, TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
};

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

 

#include "StdAfx.h"
#include "ScanFolder.h"

 

template<class Item>
ScanFolder<Item>::ScanFolder():m_bIsPostorder(FALSE){ NULL; }

template<class Item>
ScanFolder<Item>::~ScanFolder(void){ NULL; }

template<class Item>
void ScanFolder<Item>::SetOrder(BOOL bIsPostorder)
{
 m_bIsPostorder = bIsPostorder;
}

template<class Item>
BOOL ScanFolder<Item>::Scan(Item* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 if( !Init(pItem,SourceFolder,RegularExpression))
  return FALSE;
 if( !DoScan(pItem,SourceFolder,RegularExpression,_T("")))
  return FALSE;
 return TRUE;
}

template<class Item>
BOOL ScanFolder<Item>::DoScan(Item* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression, TCHAR* SubFolder)
{
 TCHAR szPath[MAX_PATH];
 _stprintf(szPath,_T("%s%s%s"),SourceFolder,SubFolder,RegularExpression);
 WIN32_FIND_DATA wfd;
 HANDLE hFile=::FindFirstFile(szPath,&wfd);
 if(hFile!=INVALID_HANDLE_VALUE)
 {
  do
  {
   if(wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
   {
    if( 0 != _tcscmp(wfd.cFileName,_T(".")) && 0 != _tcscmp(wfd.cFileName,_T("..")))
    {
     TCHAR szTemp[MAX_PATH];
     _stprintf(szTemp,_T("%s//%s"),SubFolder,wfd.cFileName);
     if( m_bIsPostorder)
     {
      if( !DoScan(pItem,SourceFolder,RegularExpression,szTemp))
       return FALSE;
      if( !ProcessItem(pItem,SourceFolder,SubFolder,&wfd))
       return FALSE;
     }
     else
     {
      if( !ProcessItem(pItem,SourceFolder,SubFolder,&wfd))
       return FALSE;
      if( !DoScan(pItem,SourceFolder,RegularExpression,szTemp))
       return FALSE;
     }
    }
   }
   else
   {
    if( !ProcessItem(pItem,SourceFolder,SubFolder,&wfd))
     return FALSE;
   }
  }while(::FindNextFile(hFile,&wfd));
  ::FindClose(hFile);
 };
 return TRUE;
}

ProcessFolder::ProcessFolder(){ NULL; }

ProcessFolder::~ProcessFolder(){ NULL; }

BOOL ProcessFolder::Init(FolderInfo* pItem, TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 SetOrder(pItem->IsPostorder());
 pItem->Init(SourceFolder,RegularExpression);
 return TRUE;
}

BOOL ProcessFolder::ProcessItem(FolderInfo* pItem, TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( pItem->Lock())
 {
  BOOL bRet = pItem->ProcessItem(SourceFolder,SubFolder, wfd);
  pItem->UnLock();
  return bRet;
 }
 return FALSE;
}

 

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

 

/********************************************************************
 created: 2011/05/07
 created: 7:5:2011   9:27
 filename:  g:/20110221文件整理/源码/UI/UI_20110447/Scan/Scan/ScanFolder.h
 file path: g:/20110221文件整理/源码/UI/UI_20110447/Scan/Scan
 file base: ScanFolder
 file ext: h
 author:  Clark
 
 purpose: Scan folder
 Use case:
    DelListInfo objScanInfo;
    ProcessFolder objProcessFolder;
    objProcessFolder.Scan(&objScanInfo,_T("//ResidentFlash//2"));
*********************************************************************/
#pragma once
#include <vector>

using namespace std;

class FolderInfo
{//带锁操作以支持实时获得数据
public:
 virtual ~FolderInfo();
 virtual BOOL Init(TCHAR* SourceFolder, TCHAR* RegularExpression) = 0;
 BOOL Lock();
 void UnLock();
 

protected:
 FolderInfo();
 virtual BOOL IsPostorder() = 0;
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd) = 0;
 friend class ProcessFolder;
 HANDLE  m_hMutex;
};

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

class SimpleScanInfo: public FolderInfo
{//扫描记录
public:
 SimpleScanInfo();
 virtual ~SimpleScanInfo();
 virtual BOOL Init(TCHAR* SourceFolder, TCHAR* RegularExpression);

protected:
 virtual BOOL IsPostorder();
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
 TCHAR m_szSrcFolder[MAX_PATH];
 TCHAR m_szRegularExpression[MAX_PATH];
 DWORD m_uSrcHSize;
 DWORD m_uSrcLSize;
 DWORD m_uSrcFile;
 DWORD m_uSrcFolder;
};

class ListScanInfo: public SimpleScanInfo
{//扫描记录并记录所有文件路径
public:
 ListScanInfo();
 virtual ~ListScanInfo();
 virtual BOOL Init(TCHAR* SourceFolder, TCHAR* RegularExpression);

protected:
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
 void   Clear();
 vector<TCHAR*> m_vFile;
 vector<TCHAR*> m_vFolder;
};

 

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

class DelInfo: public SimpleScanInfo
{//删除文件
public:
 DelInfo();
 virtual ~DelInfo();

protected:
 virtual BOOL IsPostorder();
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
};

class DelListInfo: public ListScanInfo
{//删除文件并记录删除过的文件
public:
 DelListInfo();
 virtual ~DelListInfo();

protected:
 virtual BOOL IsPostorder();
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
};

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

class CopyInfo: public SimpleScanInfo
{//拷贝文件
public:
 CopyInfo(TCHAR* szDestFolder);
 virtual ~CopyInfo();
 virtual BOOL Init(TCHAR* SourceFolder, TCHAR* RegularExpression);

protected:
 virtual BOOL IsPostorder();
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
 void   Clear();
 TCHAR   m_szDestFolder[MAX_PATH];
 DWORD   m_uCopyHSize;
 DWORD   m_uCopyLSize;
 DWORD   m_uCopyFile;
 DWORD   m_uCopyFolder;
 vector<TCHAR*> m_vErrorFile;
 vector<TCHAR*> m_vErrorFolder;
};

class CmpInfo: public SimpleScanInfo
{//对比文件
public:
 CmpInfo(TCHAR* szDestFolder);
 virtual ~CmpInfo();
 virtual BOOL Init(TCHAR* SourceFolder, TCHAR* RegularExpression);
 TCHAR   m_szDestFolder[MAX_PATH];
 DWORD   m_uDestHSize;
 DWORD   m_uDestLSize;
 DWORD   m_uDestFile;
 DWORD   m_uDestFolder;
 DWORD   m_uEquFile;
 DWORD   m_uEquFolder;
 vector<TCHAR*> m_vErrorFile;
 vector<TCHAR*> m_vErrorFolder;

protected:
 virtual BOOL IsPostorder();
 virtual BOOL ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd);
 void   Clear();
};

 

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

 

#include "StdAfx.h"
#include "FolderInfo.h"

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

 

FolderInfo::FolderInfo()
{
 TCHAR szTemp[MAX_PATH];
 _stprintf(szTemp,_T("FolderInfo_%x"),this);
 m_hMutex = CreateMutex(NULL,FALSE,szTemp);
 if( NULL == m_hMutex)
  throw _T("Failed to CreateLock!");
}

FolderInfo::~FolderInfo()
{
 if( WAIT_OBJECT_0 == WaitForSingleObject(m_hMutex,5000))
 {
  ReleaseMutex(m_hMutex);
 }
 CloseHandle(m_hMutex);
}

BOOL FolderInfo::Lock()
{
 if( WAIT_OBJECT_0 == WaitForSingleObject(m_hMutex,INFINITE))
 {
  return TRUE;
 }
 return FALSE;
}

void FolderInfo::UnLock()
{
 ReleaseMutex(m_hMutex);
}

 

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

 

SimpleScanInfo::SimpleScanInfo()
{
 Init(_T(""),_T(""));
}

SimpleScanInfo::~SimpleScanInfo()
{

}

BOOL SimpleScanInfo::IsPostorder()
{
 return TRUE;
}

BOOL SimpleScanInfo::Init(TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 m_uSrcFile = m_uSrcFolder = m_uSrcHSize = m_uSrcLSize = 0;
 _stprintf(m_szSrcFolder,_T("%s"),SourceFolder);
 _stprintf(m_szRegularExpression,_T("%s"),RegularExpression);
 return TRUE;
}

BOOL SimpleScanInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  m_uSrcFolder = m_uSrcFolder+1;
 }
 else
 {
  m_uSrcFile = m_uSrcFile+1;
  m_uSrcHSize = m_uSrcHSize+wfd->nFileSizeHigh;
  m_uSrcLSize = m_uSrcLSize+wfd->nFileSizeLow;
 }
 return TRUE;
}

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

ListScanInfo::ListScanInfo()
{
 Clear();
}

ListScanInfo::~ListScanInfo()
{
 Clear();
}

void ListScanInfo::Clear()
{
 for(int i=0; i<m_vFile.size(); i++)
 {
  if( NULL != m_vFile[i])
  {
   delete[] m_vFile[i];
   m_vFile[i] = NULL;
  }
 }
 m_vFile.clear();
 for(int i=0; i<m_vFolder.size(); i++)
 {
  if( NULL != m_vFolder[i])
  {
   delete[] m_vFolder[i];
   m_vFolder[i] = NULL;
  }
 }
 m_vFolder.clear();
}

BOOL ListScanInfo::Init(TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 if( !SimpleScanInfo::Init(SourceFolder,RegularExpression))
  return FALSE;
 Clear();
 return TRUE;
}

BOOL ListScanInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( !SimpleScanInfo::ProcessItem(SourceFolder,SubFolder,wfd))
  return FALSE;
 TCHAR* pPath = new TCHAR[_tcslen(SourceFolder)+_tcslen(SubFolder)+_tcslen(wfd->cFileName)+4];
 _stprintf(pPath,_T("%s%s//%s"),SourceFolder,SubFolder,wfd->cFileName);
 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  m_vFolder.push_back(pPath);
 }
 else
 {
  m_vFile.push_back(pPath);
 }
 return TRUE;
}

//-----------------------------------------------------------------
DelInfo::DelInfo(){ NULL; }
DelInfo::~DelInfo(){ NULL; }
BOOL DelInfo::IsPostorder()
{
 return TRUE;
}
BOOL DelInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( !SimpleScanInfo::ProcessItem(SourceFolder,SubFolder,wfd))
  return FALSE;
 TCHAR szPath[MAX_PATH];
 _stprintf(szPath,_T("%s%s//%s"),SourceFolder,SubFolder,wfd->cFileName);
 DWORD dwAttrs = ::GetFileAttributes(szPath);
 if(dwAttrs != INVALID_FILE_ATTRIBUTES)
 {
  // 取消只读属性和隐藏属性
  dwAttrs &= ~FILE_ATTRIBUTE_READONLY;
  dwAttrs &= ~FILE_ATTRIBUTE_HIDDEN;
  ::SetFileAttributes(szPath, dwAttrs);
 }
 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  RemoveDirectory(szPath);
 }
 else
 {
  DeleteFile(szPath);
 }
 return TRUE;
}

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

DelListInfo::DelListInfo(){ NULL; }
DelListInfo::~DelListInfo(){ NULL; }
BOOL DelListInfo::IsPostorder()
{
 return TRUE;
}
BOOL DelListInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( !ListScanInfo::ProcessItem(SourceFolder,SubFolder,wfd))
  return FALSE;
 TCHAR szPath[MAX_PATH];
 _stprintf(szPath,_T("%s%s//%s"),SourceFolder,SubFolder,wfd->cFileName);
 DWORD dwAttrs = ::GetFileAttributes(szPath);
 if(dwAttrs != INVALID_FILE_ATTRIBUTES)
 {
  // 取消只读属性和隐藏属性
  dwAttrs &= ~FILE_ATTRIBUTE_READONLY;
  dwAttrs &= ~FILE_ATTRIBUTE_HIDDEN;
  ::SetFileAttributes(szPath, dwAttrs);
 }
 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  RemoveDirectory(szPath);
 }
 else
 {
  DeleteFile(szPath);
 }
 return TRUE;
}

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

CopyInfo::CopyInfo(TCHAR* szDestFolder)
{
 Clear();
 _stprintf(m_szDestFolder,_T("%s"),szDestFolder);
}
CopyInfo::~CopyInfo(){ Clear(); }
BOOL CopyInfo::Init(TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 Clear();
 m_uCopyHSize = 0;
 m_uCopyLSize = 0;
 m_uCopyFile = 0;
 m_uCopyFolder = 0;

 SECURITY_ATTRIBUTES attribute;
 attribute.nLength = sizeof(attribute);
 attribute.lpSecurityDescriptor = NULL;
 attribute.bInheritHandle = FALSE;
 CreateDirectory(m_szDestFolder,&attribute);
 WIN32_FIND_DATA wfdFolder;
 HANDLE hFile=::FindFirstFile(m_szDestFolder,&wfdFolder);
 if(hFile!=INVALID_HANDLE_VALUE)
 {
  return TRUE;
 }
 return FALSE;
}

BOOL CopyInfo::IsPostorder()
{
 return FALSE;
}

BOOL CopyInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( !SimpleScanInfo::ProcessItem(SourceFolder,SubFolder,wfd))
  return FALSE;
 TCHAR szDestPath[MAX_PATH];
 _stprintf(szDestPath,_T("%s%s//%s"),m_szDestFolder,SubFolder,wfd->cFileName);
 TCHAR szSrcPath[MAX_PATH];
 _stprintf(szSrcPath,_T("%s%s//%s"),SourceFolder,SubFolder,wfd->cFileName);

 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  SECURITY_ATTRIBUTES attribute;
  attribute.nLength = sizeof(attribute);
  attribute.lpSecurityDescriptor = NULL;
  attribute.bInheritHandle = FALSE;
  CreateDirectory(szDestPath,&attribute);
  WIN32_FIND_DATA wfdFolder;
  HANDLE hFile=::FindFirstFile(szDestPath,&wfdFolder);
  if(hFile!=INVALID_HANDLE_VALUE)
  {
   m_uCopyFolder = m_uCopyFolder + 1;
  }
  else
  {
   TCHAR* pPath = new TCHAR[_tcslen(szDestPath)];
   _stprintf(pPath,_T("%s"),szDestPath);
   m_vErrorFolder.push_back(pPath);
  }
 }
 else
 {
  DWORD dwAttrs = ::GetFileAttributes(szDestPath);
  if(dwAttrs != INVALID_FILE_ATTRIBUTES)
  {
   // 取消只读属性和隐藏属性
   dwAttrs &= ~FILE_ATTRIBUTE_READONLY;
   dwAttrs &= ~FILE_ATTRIBUTE_HIDDEN;
   ::SetFileAttributes(szDestPath, dwAttrs);
   DeleteFile(szDestPath);
  }
  //存在的则覆盖
  if( CopyFile(szSrcPath,szDestPath,FALSE))
  {
   m_uCopyHSize = m_uCopyHSize + wfd->nFileSizeHigh;
   m_uCopyLSize = m_uCopyLSize + wfd->nFileSizeLow;
   m_uCopyFile = m_uCopyFile + 1;
  }
  else
  {
   TCHAR* pPath = new TCHAR[_tcslen(szDestPath)];
   _stprintf(pPath,_T("%s"),szDestPath);
   m_vErrorFile.push_back(pPath);
  }
 }
 return TRUE;
}

void CopyInfo::Clear()
{
 for(int i=0; i<m_vErrorFile.size(); i++)
 {
  if( NULL != m_vErrorFile[i])
  {
   delete[] m_vErrorFile[i];
   m_vErrorFile[i] = NULL;
  }
 }
 m_vErrorFile.clear();
 for(int i=0; i<m_vErrorFolder.size(); i++)
 {
  if( NULL != m_vErrorFolder[i])
  {
   delete[] m_vErrorFolder[i];
   m_vErrorFolder[i] = NULL;
  }
 }
 m_vErrorFolder.clear();
}

 

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

 

CmpInfo::CmpInfo(TCHAR* szDestFolder)
{
 Clear();
 _stprintf(m_szDestFolder,_T("%s"),szDestFolder);
}
CmpInfo::~CmpInfo(){ Clear(); }
BOOL CmpInfo::Init(TCHAR* SourceFolder, TCHAR* RegularExpression)
{
 Clear();
 m_uEquFile = 0;
 m_uEquFolder = 0;
 m_uDestHSize = 0;
 m_uDestLSize = 0;
 m_uDestFile = 0;
 m_uDestFolder = 0;

 SimpleScanInfo::Init(SourceFolder,RegularExpression);
 SECURITY_ATTRIBUTES attribute;
 attribute.nLength = sizeof(attribute);
 attribute.lpSecurityDescriptor = NULL;
 attribute.bInheritHandle = FALSE;
 CreateDirectory(m_szDestFolder,&attribute);
 WIN32_FIND_DATA wfdFolder;
 HANDLE hFile=::FindFirstFile(m_szDestFolder,&wfdFolder);
 if(hFile!=INVALID_HANDLE_VALUE)
 {
  return TRUE;
 }
 return FALSE;
}

BOOL CmpInfo::IsPostorder()
{
 return FALSE;
}

BOOL CmpInfo::ProcessItem(TCHAR* SourceFolder, TCHAR* SubFolder, WIN32_FIND_DATA* wfd)
{
 if( !SimpleScanInfo::ProcessItem(SourceFolder,SubFolder,wfd))
  return FALSE;
 TCHAR szDestPath[MAX_PATH];
 _stprintf(szDestPath,_T("%s%s//%s"),m_szDestFolder,SubFolder,wfd->cFileName);
 TCHAR szSrcPath[MAX_PATH];
 _stprintf(szSrcPath,_T("%s%s//%s"),SourceFolder,SubFolder,wfd->cFileName);

 if( wfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
 {
  WIN32_FIND_DATA wfdFolder;
  HANDLE hFile=::FindFirstFile(szDestPath,&wfdFolder);
  if(hFile != INVALID_HANDLE_VALUE)
  {
   m_uEquFolder = m_uEquFolder + 1;
   m_uDestFolder = m_uDestFolder + 1;
  }
  else
  {
   TCHAR* pPath = new TCHAR[_tcslen(szDestPath)];
   _stprintf(pPath,_T("%s"),szDestPath);
   m_vErrorFolder.push_back(pPath);
  }
 }
 else
 {
  WIN32_FIND_DATA wfdFolder;
  HANDLE hFile=::FindFirstFile(szDestPath,&wfdFolder);
  if( hFile != INVALID_HANDLE_VALUE)
  {
   m_uDestHSize = m_uDestHSize + wfdFolder.nFileSizeHigh;
   m_uDestLSize = m_uDestLSize + wfdFolder.nFileSizeLow;
   m_uDestFile = m_uDestFile + 1;
   if( wfdFolder.nFileSizeLow == wfd->nFileSizeLow
    && wfdFolder.nFileSizeHigh == wfd->nFileSizeHigh)
    m_uEquFile = m_uEquFile + 1;
   else
   {
    TCHAR* pPath = new TCHAR[_tcslen(szDestPath)];
    _stprintf(pPath,_T("%s"),szDestPath);
    m_vErrorFile.push_back(pPath);
   }
  }
  else
  {
   TCHAR* pPath = new TCHAR[_tcslen(szDestPath)];
   _stprintf(pPath,_T("%s"),szDestPath);
   m_vErrorFile.push_back(pPath);
  }
 }
 return TRUE;
}

void CmpInfo::Clear()
{
 for(int i=0; i<m_vErrorFile.size(); i++)
 {
  if( NULL != m_vErrorFile[i])
  {
   delete[] m_vErrorFile[i];
   m_vErrorFile[i] = NULL;
  }
 }
 m_vErrorFile.clear();
 for(int i=0; i<m_vErrorFolder.size(); i++)
 {
  if( NULL != m_vErrorFolder[i])
  {
   delete[] m_vErrorFolder[i];
   m_vErrorFolder[i] = NULL;
  }
 }
 m_vErrorFolder.clear();
}