1844 lines
48 KiB
C++
Executable File
1844 lines
48 KiB
C++
Executable File
//
|
|
// TOOLKIT.CPP
|
|
//
|
|
// Source file for ArchiveLib 2.0
|
|
//
|
|
// Copyright (c) Greenleaf Software, Inc. 1994-1996
|
|
// All Rights Reserved
|
|
//
|
|
// CONTENTS
|
|
//
|
|
// ALToolKit::operator new()
|
|
// ALToolKit::ALToolKit()
|
|
// ALToolKit::ALToolKit( const ALToolKit& )
|
|
// ALToolKit::ALToolKit( const ALCompressor & )
|
|
// ALToolKit::ALToolKit( const ALDecompressor & )
|
|
// ALToolKit::ALToolKit( const ALStorage & )
|
|
// ALToolKit::~ALToolKit()
|
|
// deleteALToolKit()
|
|
// ALToolKit::operator+( const ALCompressor & )
|
|
// ALToolKit::operator+( const ALDecompressor & )
|
|
// ALToolKit::operator+( const ALStorage & )
|
|
// operator+( ALCompressor &, ALCompressor & )
|
|
// operator+( ALCompressor &, ALDecompressor & )
|
|
// operator+( ALCompressor &, ALStorage & )
|
|
// operator+( ALDecompressor &, ALCompressor & )
|
|
// operator+( ALDecompressor &, ALDecompressor & )
|
|
// operator+( ALDecompressor &, ALStorage & )
|
|
// operator+( ALStorage &, ALCompressor & )
|
|
// operator+( ALStorage &, ALDecompressor & )
|
|
// operator+( ALStorage &, ALStorage & )
|
|
// ALToolKit::CreateCompressor()
|
|
// ALToolKit::CreateDecompressor()
|
|
// ALToolKit::CreateStorageObject()
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// A toolkit is simply a collection of compressors, decompressors,
|
|
// and storage objects. The exciting part of a toolkit is that
|
|
// I let you add any one of these objects to the kit at any time
|
|
// using operator+(). I also let you construct a toolkit
|
|
// using any of these objects.
|
|
//
|
|
// This file contains all the toolkit source code to keep all this
|
|
// working.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
#include "arclib.h"
|
|
#if !defined( AL_IBM )
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::operator new()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Memory allocator used when ArchiveLib resides in a 16 bit DLL.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// void * ALToolKit::operator new( size_t size )
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// size : The number of bytes that the compiler has decided will be
|
|
// necessary to construct a new ALToolKit object.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// When using a DLL, it is easy to get into a dangerous situation when
|
|
// creating objects whose ctor and dtor are both in the DLL. The problem
|
|
// arises because when you create an object using new, the memory for
|
|
// the object will be allocated from the EXE. However, when you destroy
|
|
// the object using delete, the memory is freed inside the DLL. Since
|
|
// the DLL doesn't really own that memory, bad things can happen.
|
|
//
|
|
// But, you say, won't the space just go back to the Windows heap regardless
|
|
// of who tries to free it? Maybe, but maybe not. If the DLL is using
|
|
// a subsegment allocation scheme, it might do some sort of local free
|
|
// before returning the space to the windows heap. That is the point where
|
|
// you could conceivably cook your heap.
|
|
//
|
|
// By providing our own version of operator new inside this class, we
|
|
// ensure that all memory allocation for the class will be done from
|
|
// inside the DLL, not the EXE calling the DLL.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A pointer to some memory that should have been pulled out of the
|
|
// heap for the DLL.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
#if defined( AL_BUILDING_DLL )
|
|
|
|
void AL_DLL_FAR * AL_PROTO
|
|
ALToolKit::operator new( size_t size ) /* Tag protected function */
|
|
{
|
|
return ::new char[ size ];
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::ALToolKit()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// The default toolkit constructor.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::ALToolKit();
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// An ALToolKit object contains three arrays: a list of compressors,
|
|
// decompressors, and storage objects. When the default constructor is
|
|
// invoked, the toolkit starts off completely empty, so all of the
|
|
// arrays are set to 0, which is a special case, meaning the list is empty.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::ALToolKit() /* Tag public function */
|
|
{
|
|
mpCompressors = 0;
|
|
mpDecompressors = 0;
|
|
mpStorages = 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::ALToolKit(const ALToolKit &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// The ALToolKit copy constructor.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::ALToolKit( const ALToolKit &rhs );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// rhs : A reference to another toolkit. This toolkit will be
|
|
// copied during the creation of the new toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// In order to provide easy manipulation of ALToolKit objects, a copy
|
|
// constructor is a necessity. The copy constructor requires that
|
|
// we create a new toolkit that is just like the rhs argument.
|
|
//
|
|
// The easiest way to make these toolkits the same would be to have
|
|
// them both point to the same lists of compressors, decompressors,
|
|
// and storage objects. But having two containers that are free to jack
|
|
// with the list at the same time would be a real monster.
|
|
//
|
|
// So, isntead, the copy constructor creates new lists. The
|
|
// elements in the list are populated using the Clone() functions,
|
|
// which should produce identical copies of the storage objects,
|
|
// compressors, and decompressors. When each item in the rsh has been
|
|
// cloned, we have a new ALToolKit that isn't a binary copy of the
|
|
// rhs, but will behave in an identical fashion.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::ALToolKit( const ALToolKit AL_DLL_FAR &rhs ) /* Tag public function */
|
|
{
|
|
int i;
|
|
//
|
|
// If the rhs has a list of compressors, clone a copy. Else set the
|
|
// list pointer to 0, indicating no compressors on hand.
|
|
//
|
|
if ( rhs.mpCompressors ) {
|
|
for ( i = 0 ; rhs.mpCompressors[ i ] ; i++ )
|
|
;
|
|
mpCompressors = new ALCompressor AL_DLL_FAR *[ i + 1 ];
|
|
if ( mpCompressors ) {
|
|
for ( i = 0 ; rhs.mpCompressors[ i ] ; i++ )
|
|
mpCompressors[ i ] = rhs.mpCompressors[ i ]->Clone( AL_COMPRESSION_DEFAULT );
|
|
mpCompressors[ i ] = 0;
|
|
}
|
|
} else
|
|
mpCompressors = 0;
|
|
//
|
|
// If the rhs has a list of decompressors, clone a copy. Else set the
|
|
// list pointer to 0, indicating no decompressors on hand.
|
|
//
|
|
if ( rhs.mpDecompressors ) {
|
|
for ( i = 0 ; rhs.mpDecompressors[ i ] ; i++ )
|
|
;
|
|
mpDecompressors = new ALDecompressor AL_DLL_FAR *[ i + 1 ];
|
|
if ( mpDecompressors ) {
|
|
for ( i = 0 ; rhs.mpDecompressors[ i ] ; i++ )
|
|
mpDecompressors[ i ] = rhs.mpDecompressors[ i ]->Clone( AL_COMPRESSION_DEFAULT );
|
|
mpDecompressors[ i ] = 0;
|
|
}
|
|
} else
|
|
mpDecompressors = 0;
|
|
//
|
|
// If the rhs has a list of storage objects, clone a copy. Else set the
|
|
// list pointer to 0, indicating no storage objects on hand.
|
|
//
|
|
if ( rhs.mpStorages ) {
|
|
for ( i = 0 ; rhs.mpStorages[ i ] ; i++ )
|
|
;
|
|
mpStorages = new ALStorage AL_DLL_FAR *[ i + 1 ];
|
|
if ( mpStorages ) {
|
|
for ( i = 0 ; rhs.mpStorages[ i ] ; i++ )
|
|
mpStorages[ i ] = rhs.mpStorages[ i ]->Clone( "", AL_STORAGE_DEFAULT );
|
|
mpStorages[ i ] = 0;
|
|
}
|
|
} else
|
|
mpStorages = 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::ALToolKit(const ALCompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Construct a new ALToolKit that contains a copy of the compressor argument.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::ALToolKit( const ALCompressor &c );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// c : A reference to a compressors. When the toolkit is constructed,
|
|
// it will contain a clone of this compressor.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// ALToolKit contains lists of compressors, decompressors, and
|
|
// storage objects. In order to make toolkit manipulation as simple
|
|
// as possible, constructors are provided that accept each of these
|
|
// types of objects as arguments. In this case, the argument is a
|
|
// reference to a compressor.
|
|
//
|
|
// The three lists are initialized in the constructor. The
|
|
// decompressor and storage object lists are initialized to be empty,
|
|
// and the compressor list has a single clone of the compressor
|
|
// specified as the rhs argument.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::ALToolKit( const ALCompressor AL_DLL_FAR &c ) /* Tag public function */
|
|
{
|
|
mpCompressors = new ALCompressor AL_DLL_FAR *[ 2 ];
|
|
if ( mpCompressors ) {
|
|
mpCompressors[ 0 ] = c.Clone( AL_COMPRESSION_DEFAULT );
|
|
mpCompressors[ 1 ] = 0;
|
|
}
|
|
mpDecompressors = 0;
|
|
mpStorages = 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::ALToolKit(const ALDecompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Construct an ALToolKit that contains a copy of the decompressor argument.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::ALToolKit( const ALDecompressor &d );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// d : A reference to a decompressor. When the toolkit is constructed,
|
|
// it will contain a clone of this decompressor.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// ALToolKit contains lists of compressors, decompressors, and
|
|
// storage objects. In order to make toolkit manipulation as simple
|
|
// as possible, constructors are provided that accept each of these
|
|
// types of objects as arguments. In this case, the argument is a
|
|
// reference to a decompressor.
|
|
//
|
|
// The three lists are initialized in the constructor. The
|
|
// compressor and storage object lists are initialized to be empty,
|
|
// and the decompressor list has a single clone of the decompressor
|
|
// specified as the rhs argument.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::ALToolKit( const ALDecompressor AL_DLL_FAR &d ) /* Tag public function */
|
|
{
|
|
mpCompressors = 0;
|
|
mpDecompressors = new ALDecompressor AL_DLL_FAR *[ 2 ];
|
|
if ( mpDecompressors ) {
|
|
mpDecompressors[ 0 ] = d.Clone( AL_COMPRESSION_DEFAULT );
|
|
mpDecompressors[ 1 ] = 0;
|
|
}
|
|
mpStorages = 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::ALToolKit(const ALStorage &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Construct an ALToolKit that contains a copy of the storage object argument.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::ALToolKit( const ALStorage &s );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// s : A reference to a storage object. When the toolkit is constructed,
|
|
// it will contain a clone of this object.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// ALToolKit contains lists of compressors, decompressors, and
|
|
// storage objects. In order to make toolkit manipulation as simple
|
|
// as possible, constructors are provided that accept each of these
|
|
// types of objects as arguments. In this case, the argument is a
|
|
// reference to a storage object.
|
|
//
|
|
// The three lists are initialized in the constructor. The
|
|
// compressor and decompressor object lists are initialized to be empty,
|
|
// and the storage object list has a single clone of the storage object
|
|
// specified as the rhs argument.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::ALToolKit( const ALStorage AL_DLL_FAR &s ) /* Tag public function */
|
|
{
|
|
mpCompressors = 0;
|
|
mpDecompressors = 0;
|
|
mpStorages = new ALStorage AL_DLL_FAR *[ 2 ];
|
|
if ( mpStorages ) {
|
|
mpStorages[ 0 ] = s.Clone( "", AL_STORAGE_DEFAULT );
|
|
mpStorages[ 1 ] = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::~ALToolKit()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// The ALToolKit destructor.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit::~ALToolKit();
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// void deleteALToolKit( hALToolKit this_object );
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// Declare Sub deleteALToolKit Lib "AL20LW" (ByVal this_object&)
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// procedure deleteALToolKit( this_object : hALArchive );
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// this_object : A reference or pointer to the ALToolKit object that
|
|
// is going to be destroyed. Note that the C++ member
|
|
// function doesn't have this_object as an argument, because
|
|
// it has implicit access to it via 'this'.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// To destroy a toolkit, you need to work through each of the three lists,
|
|
// destroying every object in the list. After destroying all the objects
|
|
// in the list, you then destroy the list itself. Note that the list may
|
|
// be empty when the destructor is called, in which case it doesn't need
|
|
// to be deleted. This is flagged by it having a 0 value.
|
|
//
|
|
// This is the only member function of ALToolKit that has a C/VB/Delphi
|
|
// translation function. These languages will get working pointers to
|
|
// constructed toolkits via the toolkit creation functions. These toolkits
|
|
// must be deleted in order to prevent memory leaks, so we have to have
|
|
// a translation function.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_PROTO
|
|
ALToolKit::~ALToolKit() /* Tag public function */
|
|
{
|
|
int i;
|
|
|
|
if ( mpCompressors ) {
|
|
for ( i = 0 ; mpCompressors[ i ] ; i++ )
|
|
delete mpCompressors[ i ];
|
|
delete[] mpCompressors;
|
|
}
|
|
if ( mpDecompressors ) {
|
|
for ( i = 0 ; mpDecompressors[ i ] ; i++ )
|
|
delete mpDecompressors[ i ];
|
|
delete[] mpDecompressors;
|
|
}
|
|
if ( mpStorages ) {
|
|
for ( i = 0 ; mpStorages[ i ] ; i++ )
|
|
delete mpStorages[ i ];
|
|
delete[] mpStorages;
|
|
}
|
|
}
|
|
|
|
#if !defined( AL_NO_C )
|
|
|
|
extern "C" AL_LINKAGE void AL_FUNCTION
|
|
deleteALToolKit( hALToolKit this_object ) /* Tag public function */
|
|
{
|
|
AL_ASSERT_OBJECT( this_object, ALToolKit, "deleteALToolKit()" );
|
|
delete (ALToolKit *) this_object;
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::operator+( const ALCompressor &c )
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Add a compressor object to a toolkit.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit &ALToolKit::operator+( const ALCompressor &c );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// c : A reference to an ALCompressor object. A copy of this object
|
|
// will be added to the toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of three member operators that allow you to add a new
|
|
// object to an existing toolkit. The function just has to either create
|
|
// a new list for the object, or expand the existing object by one entry.
|
|
// The object is then copied into the list using the Clone() function.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A reference to the toolkit. This is done in standard C++ style to
|
|
// allow cascaded operations.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALToolKit AL_DLL_FAR & AL_PROTO
|
|
ALToolKit::operator+( const ALCompressor AL_DLL_FAR &c ) /* Tag public function */
|
|
{
|
|
if ( mpCompressors ) {
|
|
int i;
|
|
for ( i = 0 ; mpCompressors[ i ] ; i++ )
|
|
;
|
|
ALCompressor AL_DLL_FAR **p = new ALCompressor AL_DLL_FAR *[ i + 2 ];
|
|
if ( p ) {
|
|
for ( int j = 0 ; j < i ; j++ )
|
|
p[ j ] = mpCompressors[ j ];
|
|
p[ i ] = c.Clone( AL_COMPRESSION_DEFAULT );
|
|
p[ i + 1 ] = 0;
|
|
delete[] mpCompressors;
|
|
mpCompressors = p;
|
|
}
|
|
|
|
} else {
|
|
mpCompressors = new ALCompressor AL_DLL_FAR *[ 2 ];
|
|
if ( mpCompressors ) {
|
|
mpCompressors[ 0 ] = c.Clone( AL_COMPRESSION_DEFAULT );
|
|
mpCompressors[ 1 ] = 0;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::operator+( const ALDecompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Add a decompressor object to a toolkit.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit &ALToolKit::operator+( const ALDecompressor &d );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// d : A reference to an ALDecompressor object. A copy of this object
|
|
// will be added to the toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of three member operators that allow you to add a new
|
|
// object to an existing toolkit. The function just has to either create
|
|
// a new list for the object, or expand the existing list by one entry.
|
|
// The object is then copied into the list using the Clone() function.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A reference to the toolkit. This is done in standard C++ style to
|
|
// allow cascaded operations.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALToolKit AL_DLL_FAR & AL_PROTO
|
|
ALToolKit::operator+( const ALDecompressor AL_DLL_FAR &d ) /* Tag public function */
|
|
{
|
|
if ( mpDecompressors ) {
|
|
int i;
|
|
for ( i = 0 ; mpDecompressors[ i ] ; i++ )
|
|
;
|
|
ALDecompressor AL_DLL_FAR **p = new ALDecompressor AL_DLL_FAR *[ i + 2 ];
|
|
if ( p ) {
|
|
for ( int j = 0 ; j < i ; j++ )
|
|
p[ j ] = mpDecompressors[ j ];
|
|
p[ i ] = d.Clone( AL_COMPRESSION_DEFAULT );
|
|
p[ i + 1 ] = 0;
|
|
delete[] mpDecompressors;
|
|
mpDecompressors = p;
|
|
}
|
|
} else {
|
|
mpDecompressors = new ALDecompressor AL_DLL_FAR *[ 2 ];
|
|
if ( mpDecompressors ) {
|
|
mpDecompressors[ 0 ] = d.Clone( AL_COMPRESSION_DEFAULT );
|
|
mpDecompressors[ 1 ] = 0;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::operator+( const ALStorage &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Add a storage object to a toolkit.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit &ALToolKit::operator+( const ALStorage &d );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// s : A reference to an ALStorage object. A copy of this object
|
|
// will be added to the toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of three member operators that allow you to add a new
|
|
// object to an existing toolkit. The function just has to either create
|
|
// a new list for the object, or expand the existing list by one entry.
|
|
// The object is then copied into the list using the Clone() function.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A reference to the toolkit. This is done in standard C++ style to
|
|
// allow cascaded operations.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALToolKit AL_DLL_FAR & AL_PROTO
|
|
ALToolKit::operator+( const ALStorage AL_DLL_FAR &s ) /* Tag public function */
|
|
{
|
|
if ( mpStorages ) {
|
|
int i;
|
|
for ( i = 0 ; mpStorages[ i ] ; i++ )
|
|
;
|
|
ALStorage AL_DLL_FAR **p = new ALStorage AL_DLL_FAR *[ i + 2 ];
|
|
if ( p ) {
|
|
for ( int j = 0 ; j < i ; j++ )
|
|
p[ j ] = mpStorages[ j ];
|
|
p[ i ] = s.Clone( "", AL_STORAGE_DEFAULT );
|
|
p[ i + 1 ] = 0;
|
|
delete[] mpStorages;
|
|
mpStorages = p;
|
|
}
|
|
} else {
|
|
mpStorages = new ALStorage AL_DLL_FAR *[ 2 ];
|
|
if ( mpStorages ) {
|
|
mpStorages[ 0 ] = s.Clone( "", AL_STORAGE_DEFAULT );
|
|
mpStorages[ 1 ] = 0;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALCompressor &,const ALCompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with two ALCompressor objects.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALCompressor &c1,
|
|
// const ALCompressor &c2 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// c1 : A reference to an ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// c2 : A reference to a second ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALCompressor AL_DLL_FAR & c1, /* Tag public function */
|
|
const ALCompressor AL_DLL_FAR & c2 )
|
|
{
|
|
ALToolKit a( c1 );
|
|
return a + c2;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALCompressor &,const ALDecompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with and ALCompressor and ALDecompressor object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALCompressor &c1,
|
|
// const ALDecompressor &d1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// c1 : A reference to an ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// d1 : A reference to an ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALCompressor AL_DLL_FAR & c1, /* Tag public function */
|
|
const ALDecompressor AL_DLL_FAR & d1 )
|
|
{
|
|
ALToolKit a( c1 );
|
|
return a + d1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALCompressor &,const ALStorage &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with and ALCompressor and ALStorage object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALCompressor &c1,
|
|
// const ALStorage &s1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// c1 : A reference to an ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// s1 : A reference to an ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALCompressor AL_DLL_FAR & c1, /* Tag public function */
|
|
const ALStorage AL_DLL_FAR & s1 )
|
|
{
|
|
ALToolKit a( c1 );
|
|
return a + s1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALDecompressor &,const ALCompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with and ALDecompressor and ALCompressor object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALDecompressor &d1,
|
|
// const ALCompressor &c1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// d1 : A reference to an ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// c1 : A reference to an ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALDecompressor AL_DLL_FAR & d1, /* Tag public function */
|
|
const ALCompressor AL_DLL_FAR & c1 )
|
|
{
|
|
ALToolKit a( d1 );
|
|
return a + c1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALDecompressor &,const ALDecompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with two ALDecompressor objects.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALDecompressor &d1,
|
|
// const ALDecompressor &d2 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// d1 : A reference to an ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// d2 : A reference to a second ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALDecompressor AL_DLL_FAR & d1, /* Tag public function */
|
|
const ALDecompressor AL_DLL_FAR & d2 )
|
|
{
|
|
ALToolKit a( d1 );
|
|
return a + d2;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALDecompressor &,const ALStorage &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with an ALDecompressor and an ALStorage object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALDecompressor &d1,
|
|
// const ALStorage &s1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// d1 : A reference to an ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// s1 : A reference to an ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALDecompressor AL_DLL_FAR & d1, /* Tag public function */
|
|
const ALStorage AL_DLL_FAR & s1 )
|
|
{
|
|
ALToolKit a( d1 );
|
|
return a + s1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALStorage &,const ALCompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with an ALStorage and an ALCompressor object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALStorage &s1,
|
|
// const ALCompressor &c1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// s1 : A reference to an ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// c1 : A reference to an ALCompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALStorage AL_DLL_FAR & s1, /* Tag public function */
|
|
const ALCompressor AL_DLL_FAR & c1 )
|
|
{
|
|
ALToolKit a( s1 );
|
|
return a + c1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALStorage &,const ALDecompressor &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with an ALStorage and an ALDecompressor object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALStorage &s1,
|
|
// const ALDecompressor &d1 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// s1 : A reference to an ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// d1 : A reference to an ALDecompressor object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALStorage AL_DLL_FAR & s1, /* Tag public function */
|
|
const ALDecompressor AL_DLL_FAR & d1 )
|
|
{
|
|
ALToolKit a( s1 );
|
|
return a + d1;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// operator+( const ALStorage &,const ALStorage &)
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create a toolkit with two ALStorage objects.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALToolKit operator+( const ALStorage &s1,
|
|
// const ALStorage &s2 );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// s1 : A reference to an ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// s2 : A reference to a second ALStorage object. A copy of this
|
|
// object will be added to the resulting toolkit.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is one of 9 global operators that overload the '+' symbol for
|
|
// ALCompressor, ALDecompressor, and ALStorage objects. The operator
|
|
// creates an ALToolKit that is initialized with clones of the two
|
|
// input objects. These operators are provided to make it more convenient
|
|
// to create ALToolKit objects, using syntax like this:
|
|
//
|
|
// ALToolKit tk = ALFile() + ALCopyCompressor() + ALHugeMemory().
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A newly created toolkit. Since the toolkit has a copy constructor
|
|
// defined, we can get away with this, as opposed to returning a pointer
|
|
// to a newly created toolkit object. This is a lot nicer.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// November 13, 1995 2.00A : First release.
|
|
//
|
|
|
|
AL_LINKAGE ALToolKit AL_FUNCTION
|
|
operator+( const ALStorage AL_DLL_FAR & s1, /* Tag public function */
|
|
const ALStorage AL_DLL_FAR & s2 )
|
|
{
|
|
ALToolKit a( s1 );
|
|
return a + s2;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::CreateCompressor()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create an ALCompressor object based on a given type.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALCompressor * ALToolKit::CreateCompressor( int engine_type );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// int engine_type : An integer that describes the desirede engine type.
|
|
// This is normally either an integer that was stored
|
|
// in an archive along with a compressed object, or
|
|
// the AL_COMPRESSION_DEFAULT that is used to ask for
|
|
// the first available engine.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function and its two siblings constitute the whole reason for the
|
|
// esistence of a toolkit. When inserting objects int an entry list, this
|
|
// routine is called to build the appropriate engine. The engine that
|
|
// actually gets selected will depend on which toolkit has been passed
|
|
// in the ALEntryList constructor. This means that that archiving and
|
|
// entry list functions can operate without any knowledge about specific
|
|
// compression engines, which means they won't link in any engines that
|
|
// aren't included in your toolkit.
|
|
//
|
|
// This function works by repeatedly trying to clone each of the engines
|
|
// in the compression engine list. The Clone() function is called with
|
|
// the engine_type argument. If the compression engine feels it can
|
|
// construct an engine that matches that type, it will return a cloned
|
|
// copy. If not, it returns a 0.
|
|
//
|
|
// As soon as one of the Clone() calls succeeds, this function will pass
|
|
// back a copy of the created engine. Otherwise it will keep trying until
|
|
// it runs out of engines to clone. When it finally fails, it returns
|
|
// a 0.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Either a pointer to a newly created compression engine, or a 0 if no
|
|
// engine could be created for the given type.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALCompressor AL_DLL_FAR * AL_PROTO
|
|
ALToolKit::CreateCompressor( int engine_type ) /* Tag public function */
|
|
{
|
|
if ( !mpCompressors )
|
|
return 0;
|
|
for ( int i = 0 ; ; ) {
|
|
ALCompressor *compressor;
|
|
if ( mpCompressors[ i ] ) {
|
|
compressor = mpCompressors[ i++ ]->Clone( engine_type );
|
|
if ( compressor )
|
|
return compressor;
|
|
} else
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::CreateDecompressor()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create an ALDecompressor object based on a given engine type.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALDecompressor * ALToolKit::CreateDecompressor( int engine_type );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// int engine_type : An integer that describes the desired engine type.
|
|
// This is normally either an integer that was stored
|
|
// in an archive along with a compressed object, or
|
|
// the AL_COMPRESSION_DEFAULT that is used to ask for
|
|
// the first available engine.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function and its two siblings constitute the whole reason for the
|
|
// esistence of a toolkit. When extracting objects from an archive, this
|
|
// routine is called to build the appropriate engine. The engine that
|
|
// actually gets built will depend on which toolkit has been passed
|
|
// in the ALEntryList constructor. This means that that archiving and
|
|
// entry list functions can operate without any knowledge about specific
|
|
// de/compression engines, which means they won't link in any engines that
|
|
// aren't included in your toolkit.
|
|
//
|
|
// This function works by repeatedly trying to clone each of the engines
|
|
// in the decompression engine list. The Clone() function is called with
|
|
// the engine_type argument. If the decompression engine feels it can
|
|
// construct a copy of itself that matches that type, it will return a cloned
|
|
// decompression engine. If not, it returns a 0.
|
|
//
|
|
// As soon as one of the Clone() calls succeeds, this function will pass
|
|
// back a copy of the created engine. Otherwise it will keep trying until
|
|
// it runs out of engines to clone. When it finally fails, it returns
|
|
// a 0.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Either a pointer to a newly created decompression engine, or a 0 if no
|
|
// engine could be created for the given type.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALDecompressor AL_DLL_FAR * AL_PROTO
|
|
ALToolKit::CreateDecompressor( int engine_type ) /* Tag public function */
|
|
{
|
|
if ( !mpDecompressors )
|
|
return 0;
|
|
for ( int i = 0 ; ; ) {
|
|
ALDecompressor *decompressor;
|
|
if ( mpDecompressors[ i ] ) {
|
|
decompressor = mpDecompressors[ i++ ]->Clone( engine_type );
|
|
if ( decompressor )
|
|
return decompressor;
|
|
} else
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALToolKit::CreateStorageObject()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Create an ALStorage object based on a given object type.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALStorage * ALToolKit::CreateStorageObject( int object_type );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, ALToolkit operations aren't available in C/VB/Delphi.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// int object_type : An integer that describes the desired object type.
|
|
// This is normally either an integer that was stored
|
|
// in an archive along with a compressed object, or
|
|
// the AL_STORAGE_DEFAULT that is used to ask for
|
|
// the first available storage object.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function and its two siblings constitute the whole reason for the
|
|
// esistence of a toolkit. When extracting objects from an archvie,
|
|
// this routine is called to build the empty objects. The object that
|
|
// actually gets built will depend on which toolkit has been passed
|
|
// in the ALEntryList constructor. This means that that archiving and
|
|
// entry list functions can operate without any knowledge about specific
|
|
// ALStorage objec types, which means they won't link in any types that
|
|
// aren't included in your toolkit.
|
|
//
|
|
// This function works by repeatedly trying to clone each of the objects
|
|
// in the storage object list. The Clone() function is called with
|
|
// the object_type argument. If the storage object feels it can
|
|
// construct a copy of itself that matches that type, it will return a cloned
|
|
// storage object. If not, it returns a 0.
|
|
//
|
|
// As soon as one of the Clone() calls succeeds, this function will pass
|
|
// back a copy of the storage object. Otherwise it will keep trying until
|
|
// it runs out of objects to clone. When it finally fails, it returns
|
|
// a 0.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Either a pointer to a newly created storage object, or a 0 if no
|
|
// object could be created for the given type.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release.
|
|
//
|
|
|
|
ALStorage AL_DLL_FAR * AL_PROTO
|
|
ALToolKit::CreateStorageObject( const char AL_DLL_FAR *name, /* Tag public function */
|
|
int object_type )
|
|
{
|
|
if ( !mpStorages )
|
|
return 0;
|
|
for ( int i = 0 ; ; ) {
|
|
ALStorage *storage;
|
|
if ( mpStorages[ i ] ) {
|
|
storage = mpStorages[ i++ ]->Clone( name, object_type );
|
|
if ( storage )
|
|
return storage;
|
|
} else
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|