// ============================================================================
//  Copyright (C) 2001-2010 by Jozef Starosczyk
//  ixen@copyhandler.com
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Library General Public License
//  (version 2) as published by the Free Software Foundation;
//
//  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 Library 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.
// ============================================================================
/// @file  TTaskConfiguration.cpp
/// @date  2010/09/18
/// @brief Contains implementation of class TTaskConfiguration.
// ============================================================================
#include "stdafx.h"
#include "TTaskConfiguration.h"


///////////////////////////////////////////////////////////////////////////
// TSubTaskCommonConfig

TSubTaskCommonConfig::TSubTaskCommonConfig() :
	m_nPriority(THREAD_PRIORITY_NORMAL),
	m_bDeleteAllFilesAfterAllCopyings(true),
	m_bIgnoreReadOnlyAttributes(false)
{
}

TSubTaskCommonConfig::TSubTaskCommonConfig(const TSubTaskCommonConfig& rSrc) :
   m_nPriority(THREAD_PRIORITY_NORMAL),
   m_bDeleteAllFilesAfterAllCopyings(true),
   m_bIgnoreReadOnlyAttributes(false)
{
   *this = rSrc;
}

TSubTaskCommonConfig::~TSubTaskCommonConfig()
{
}

TSubTaskCommonConfig& TSubTaskCommonConfig::operator=(const TSubTaskCommonConfig& rSrc)
{
   if(this != &rSrc)
   {
      boost::shared_lock<boost::shared_mutex> src_lock(rSrc.m_lock);
      boost::unique_lock<boost::shared_mutex> lock(m_lock);

      m_nPriority = rSrc.m_nPriority;
      m_bDeleteAllFilesAfterAllCopyings = rSrc.m_bDeleteAllFilesAfterAllCopyings;
      m_bIgnoreReadOnlyAttributes = rSrc.m_bIgnoreReadOnlyAttributes;
   }

   return *this;
}

void TSubTaskCommonConfig::SetPriority(int iPriority)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_nPriority = iPriority;
}

int TSubTaskCommonConfig::GetPriority() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_nPriority;
}

void TSubTaskCommonConfig::SetDeleteAllFilesAfterAllCopyings(bool bSeparateDelete)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bDeleteAllFilesAfterAllCopyings = bSeparateDelete;
}

bool TSubTaskCommonConfig::GetDeleteAllFilesAfterAllCopyings() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bDeleteAllFilesAfterAllCopyings;
}

void TSubTaskCommonConfig::SetIgnoreReadOnlyAttributes(bool bIgnoreReadOnlyAttributes)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bIgnoreReadOnlyAttributes = bIgnoreReadOnlyAttributes;
}

bool TSubTaskCommonConfig::GetIgnoreReadOnlyAttributes() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bIgnoreReadOnlyAttributes;
}

////////////////////////////////////////////////////////////////////////////
// class TSubTaskScanDirectoriesConfig

TSubTaskScanDirectoriesConfig::TSubTaskScanDirectoriesConfig() :
   m_afFilters()
{
}

TSubTaskScanDirectoriesConfig::TSubTaskScanDirectoriesConfig(const TSubTaskScanDirectoriesConfig& rSrc) :
   m_afFilters()
{
   *this = rSrc;
}

TSubTaskScanDirectoriesConfig::~TSubTaskScanDirectoriesConfig()
{
}

TSubTaskScanDirectoriesConfig& TSubTaskScanDirectoriesConfig::operator=(const TSubTaskScanDirectoriesConfig& rSrc)
{
   if(this != &rSrc)
   {
      boost::shared_lock<boost::shared_mutex> src_lock(rSrc.m_lock);
      boost::unique_lock<boost::shared_mutex> lock(m_lock);

      m_afFilters = rSrc.m_afFilters;
   }

   return *this;
}

void TSubTaskScanDirectoriesConfig::SetFilters(const CFiltersArray& rFilters)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_afFilters = rFilters;
}

////////////////////////////////////////////////////////////////////////////
// class TSubTaskCopyMoveConfig

TSubTaskCopyMoveConfig::TSubTaskCopyMoveConfig() :
	m_bDisableSystemBuffering(false),
	m_ullMinSizeToDisableBuffering(0),
	m_bPreserveFileDateTime(false),
	m_bPreserveFileAttributes(false),
	m_bIgnoreDirectories(false),
	m_bCreateEmptyFiles(false),
	m_bCreateOnlyDirectories(false)
{
	m_bsSizes.m_uiDefaultSize = 0;
	m_bsSizes.m_uiOneDiskSize = 0;
	m_bsSizes.m_uiTwoDisksSize = 0;
	m_bsSizes.m_uiCDSize = 0;
	m_bsSizes.m_uiLANSize = 0;
	m_bsSizes.m_bOnlyDefault = false;
}

TSubTaskCopyMoveConfig::TSubTaskCopyMoveConfig(const TSubTaskCopyMoveConfig& rSrc) :
   m_bDisableSystemBuffering(false),
   m_ullMinSizeToDisableBuffering(0),
   m_bPreserveFileDateTime(false),
   m_bPreserveFileAttributes(false),
   m_bIgnoreDirectories(false),
   m_bCreateEmptyFiles(false),
   m_bCreateOnlyDirectories(false)
{
   *this = rSrc;
}

TSubTaskCopyMoveConfig::~TSubTaskCopyMoveConfig()
{
}

TSubTaskCopyMoveConfig& TSubTaskCopyMoveConfig::operator=(const TSubTaskCopyMoveConfig& rSrc)
{
   if(this != &rSrc)
   {
      m_bDisableSystemBuffering = rSrc.m_bDisableSystemBuffering;
      m_ullMinSizeToDisableBuffering = rSrc.m_ullMinSizeToDisableBuffering;
      m_bPreserveFileDateTime = rSrc.m_bPreserveFileDateTime;
      m_bPreserveFileAttributes = rSrc.m_bPreserveFileAttributes;
      m_bIgnoreDirectories = rSrc.m_bIgnoreDirectories;
      m_bCreateEmptyFiles = rSrc.m_bCreateEmptyFiles;
      m_bCreateOnlyDirectories = rSrc.m_bCreateOnlyDirectories;
      m_bsSizes = rSrc.m_bsSizes;
   }

   return *this;
}

void TSubTaskCopyMoveConfig::SetDisableSystemBuffering(bool bDisableBuffering)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bDisableSystemBuffering = bDisableBuffering;
}

bool TSubTaskCopyMoveConfig::GetDisableSystemBuffering() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bDisableSystemBuffering;
}

void TSubTaskCopyMoveConfig::SetMinSizeToDisableBuffering(unsigned long long ullMinSize)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_ullMinSizeToDisableBuffering = ullMinSize;
}

unsigned long long TSubTaskCopyMoveConfig::GetMinSizeToDisableBuffering() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_ullMinSizeToDisableBuffering;
}

void TSubTaskCopyMoveConfig::SetPreserveFileDateTime(bool bPreserve)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bPreserveFileDateTime = bPreserve;
}

bool TSubTaskCopyMoveConfig::GetPreserveFileDateTime() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bPreserveFileDateTime;
}

void TSubTaskCopyMoveConfig::SetPreserveFileAttributes(bool bPreserve)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bPreserveFileAttributes = bPreserve;
}

bool TSubTaskCopyMoveConfig::GetPreserveFileAttributes() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bPreserveFileAttributes;
}

void TSubTaskCopyMoveConfig::SetBufferSizes(const BUFFERSIZES& bsSizes)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bsSizes = bsSizes;
}

BUFFERSIZES TSubTaskCopyMoveConfig::GetBufferSizes() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bsSizes;
}

void TSubTaskCopyMoveConfig::SetIgnoreDirectories(bool bIgnore)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bIgnoreDirectories = bIgnore;
}

bool TSubTaskCopyMoveConfig::GetIgnoreDirectories() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bIgnoreDirectories;
}

void TSubTaskCopyMoveConfig::SetCreateEmptyFiles(bool bCreateEmpty)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bCreateEmptyFiles = bCreateEmpty;
}

bool TSubTaskCopyMoveConfig::GetCreateEmptyFiles() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bCreateEmptyFiles;
}

void TSubTaskCopyMoveConfig::SetCreateOnlyDirectories(bool bCreateOnlyDirs)
{
	boost::unique_lock<boost::shared_mutex> lock(m_lock);
	m_bCreateOnlyDirectories = bCreateOnlyDirs;
}

bool TSubTaskCopyMoveConfig::GetCreateOnlyDirectories() const
{
	boost::shared_lock<boost::shared_mutex> lock(m_lock);
	return m_bCreateOnlyDirectories;
}

////////////////////////////////////////////////////////////////////////////
// class TTaskConfiguration

TTaskConfiguration::TTaskConfiguration()
{
}

TTaskConfiguration::~TTaskConfiguration()
{
}