PROJECT_ARCHIVER Class Reference

#include <project_archiver.h>

Public Member Functions
	PROJECT_ARCHIVER ()
	~PROJECT_ARCHIVER ()=default
bool	Archive (const wxString &aSrcDir, const wxString &aDestFile, REPORTER &aReporter, bool aVerbose=true, bool aIncludeExtraFiles=false)
	Creates an archive of the project. More...
bool	Unarchive (const wxString &aSrcFile, const wxString &aDestDir, REPORTER &aReporter)
	Extracts an archive of the current project over existing files Warning: this will overwrite files in the project directory. More...

Detailed Description

Definition at line 31 of file project_archiver.h.

Constructor & Destructor Documentation

PROJECT_ARCHIVER()

PROJECT_ARCHIVER::PROJECT_ARCHIVER

(

)

Definition at line 39 of file project_archiver.cpp.

{
}

~PROJECT_ARCHIVER()

PROJECT_ARCHIVER::~PROJECT_ARCHIVER ( )

default

Member Function Documentation

Archive()

bool PROJECT_ARCHIVER::Archive	(	const wxString &	aSrcDir,
		const wxString &	aDestFile,
		REPORTER &	aReporter,
		bool	aVerbose = true,
		bool	aIncludeExtraFiles = false
	)

Creates an archive of the project.

Parameters

aSrcFile	is the full path to the project to be archived
aDestFile	is the full path to the zip file to be created
aReporter	is used to report status
aVerbose	controls the verbosity of reported status messages
aIncludeExtraFiles	if true will archive legacy and output files

Returns

true if the archive was created successfully

Definition at line 110 of file project_archiver.cpp.

{
 // List of file extensions that are always archived
 static const wxChar* extensionList[] = {
 wxT( "*.kicad_pro" ),
 wxT( "*.kicad_prl" ),
 wxT( "*.kicad_sch" ),
 wxT( "*.kicad_sym" ),
 wxT( "*.kicad_pcb" ),
 wxT( "*.kicad_mod" ),
 wxT( "*.kicad_dru" ),
 wxT( "*.kicad_wks" ),
 wxT( "fp-lib-table" ),
 wxT( "sym-lib-table" )
 };
 
 // List of additional file extensions that are only archived when aIncludeExtraFiles is true
 static const wxChar* extraExtensionList[] = {
 wxT( "*.pro" ),
 wxT( "*.sch" ), // Legacy schematic files
 wxT( "*.lib" ), wxT( "*.dcm" ), // Legacy schematic library files
 wxT( "*.cmp" ),
 wxT( "*.brd" ),
 wxT( "*.mod" ),
 wxT( "*.stp" ), wxT( "*.step" ), // 3d files
 wxT( "*.wrl" ),
 wxT( "*.g?" ), wxT( "*.g??" ), // Gerber files
 wxT( "*.gm??" ), wxT( "*.gbrjob" ),
 wxT( "*.pos" ), wxT( "*.drl" ), wxT( "*.nc" ), wxT( "*.xnc" ), // Fab files
 wxT( "*.d356" ),
 wxT( "*.rpt" ),
 wxT( "*.net" ),
 wxT( "*.py" ),
 wxT( "*.pdf" ),
 wxT( "*.txt" ),
 wxT( "*.cir" ), wxT( "*.sub" ), wxT( "*.model" ), // SPICE files
 wxT( "*.ibs" )
 };
 
 bool success = true;
 wxString msg;
 wxString oldCwd = wxGetCwd();
 
 wxSetWorkingDirectory( aSrcDir );
 
 wxFFileOutputStream ostream( aDestFile );
 
 if( !ostream.IsOk() ) // issue to create the file. Perhaps not writable dir
 {
 msg.Printf( _( "Failed to create file '%s'." ), aDestFile );
 aReporter.Report( msg, RPT_SEVERITY_ERROR );
 return false;
 }
 
 wxZipOutputStream zipstream( ostream, -1, wxConvUTF8 );
 
 // Build list of filenames to put in zip archive
 wxString currFilename;
 
 wxArrayString files;
 
 for( unsigned ii = 0; ii < arrayDim( extensionList ); ii++ )
 wxDir::GetAllFiles( aSrcDir, &files, extensionList[ii] );
 
 if( aIncludeExtraFiles )
 {
 for( unsigned ii = 0; ii < arrayDim( extraExtensionList ); ii++ )
 wxDir::GetAllFiles( aSrcDir, &files, extraExtensionList[ii] );
 }
 
 for( unsigned ii = 0; ii < files.GetCount(); ++ii )
 {
 if( files[ii].EndsWith( wxS( ".ibs" ) ) )
 {
 wxFileName package( files[ ii ] );
 package.MakeRelativeTo( aSrcDir );
 package.SetExt( wxS( "pkg" ) );
 
 if( package.Exists() )
 files.push_back( package.GetFullName() );
 }
 }
 
 files.Sort();
 
 unsigned long uncompressedBytes = 0;
 
 for( unsigned ii = 0; ii < files.GetCount(); ii++ )
 {
 wxFileSystem fsfile;
 
 wxFileName curr_fn( files[ii] );
 curr_fn.MakeRelativeTo( aSrcDir );
 currFilename = curr_fn.GetFullPath();
 
 // Read input file and add it to the zip file:
 wxFSFile* infile = fsfile.OpenFile( wxFileSystem::FileNameToURL( curr_fn ) );
 
 if( infile )
 {
 zipstream.PutNextEntry( currFilename, infile->GetModificationTime() );
 infile->GetStream()->Read( zipstream );
 zipstream.CloseEntry();
 
 uncompressedBytes += infile->GetStream()->GetSize();
 
 if( aVerbose )
 {
 msg.Printf( _( "Archived file '%s'." ), currFilename );
 aReporter.Report( msg, RPT_SEVERITY_INFO );
 }
 
 delete infile;
 }
 else
 {
 if( aVerbose )
 {
 msg.Printf( _( "Failed to archive file '%s'." ), currFilename );
 aReporter.Report( msg, RPT_SEVERITY_ERROR );
 }
 
 success = false;
 }
 }
 
 auto reportSize =
 []( unsigned long aSize ) -> wxString
 {
 constexpr float KB = 1024.0;
 constexpr float MB = KB * 1024.0;
 
 if( aSize >= MB )
 return wxString::Format( wxT( "%0.2f MB" ), aSize / MB );
 else if( aSize >= KB )
 return wxString::Format( wxT( "%0.2f KB" ), aSize / KB );
 else
 return wxString::Format( wxT( "%lu bytes" ), aSize );
 };
 
 size_t zipBytesCnt = ostream.GetSize();
 
 if( zipstream.Close() )
 {
 msg.Printf( _( "Zip archive '%s' created (%s uncompressed, %s compressed)." ),
 aDestFile,
 reportSize( uncompressedBytes ),
 reportSize( zipBytesCnt ) );
 aReporter.Report( msg, RPT_SEVERITY_INFO );
 }
 else
 {
 msg.Printf( wxT( "Failed to create file '%s'." ), aDestFile );
 aReporter.Report( msg, RPT_SEVERITY_ERROR );
 success = false;
 }
 
 wxSetWorkingDirectory( oldCwd );
 return success;
}

References _, arrayDim(), extensionList, Format(), REPORTER::Report(), RPT_SEVERITY_ERROR, and RPT_SEVERITY_INFO.

Referenced by SETTINGS_MANAGER::BackupProject(), and KICAD_MANAGER_FRAME::OnArchiveFiles().

Unarchive()

bool PROJECT_ARCHIVER::Unarchive	(	const wxString &	aSrcFile,
		const wxString &	aDestDir,
		REPORTER &	aReporter
	)

Extracts an archive of the current project over existing files Warning: this will overwrite files in the project directory.

Use with care. The caller is responsible for doing any reloading of state after taking this action.

Parameters

aSrcFile	is the full path to the archive to extract
aDestDir	is the target directory to unarchive to
aReporter	is used to report status

Returns

true if the archive was created successfully

Definition at line 45 of file project_archiver.cpp.

{
 wxFFileInputStream stream( aSrcFile );
 
 if( !stream.IsOk() )
 {
 aReporter.Report( _( "Could not open archive file." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 const wxArchiveClassFactory* archiveClassFactory =
 wxArchiveClassFactory::Find( aSrcFile, wxSTREAM_FILEEXT );
 
 if( !archiveClassFactory )
 {
 aReporter.Report( _( "Invalid archive file format." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 wxScopedPtr<wxArchiveInputStream> archiveStream( archiveClassFactory->NewStream( stream ) );
 
 wxString fileStatus;
 
 for( wxArchiveEntry* entry = archiveStream->GetNextEntry(); entry;
 entry = archiveStream->GetNextEntry() )
 {
 fileStatus.Printf( _( "Extracting file '%s'." ), entry->GetName() );
 aReporter.Report( fileStatus, RPT_SEVERITY_INFO );
 
 wxString fullname = aDestDir + entry->GetName();
 
 // Ensure the target directory exists and create it if not
 wxString t_path = wxPathOnly( fullname );
 
 if( !wxDirExists( t_path ) )
 {
 wxFileName::Mkdir( t_path, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
 }
 
 // Directory entries need only be created, not extracted (0 size)
 if( entry->IsDir() )
 continue;
 
 
 wxTempFileOutputStream outputFileStream( fullname );
 
 if( CopyStreamData( *archiveStream, outputFileStream, entry->GetSize() ) )
 outputFileStream.Commit();
 else
 aReporter.Report( _( "Error extracting file!" ), RPT_SEVERITY_ERROR );
 
 // Now let's set the filetimes based on what's in the zip
 wxFileName outputFileName( fullname );
 wxDateTime fileTime = entry->GetDateTime();
 // For now we set access, mod, create to the same datetime
 // create (third arg) is only used on Windows
 outputFileName.SetTimes( &fileTime, &fileTime, &fileTime );
 }
 
 aReporter.Report( wxT( "Extracted project." ), RPT_SEVERITY_INFO );
 return true;
}

References _, CopyStreamData(), REPORTER::Report(), RPT_SEVERITY_ERROR, and RPT_SEVERITY_INFO.

Referenced by KICAD_MANAGER_FRAME::OnUnarchiveFiles().

---

The documentation for this class was generated from the following files:

• project_archiver.h
• project_archiver.cpp