//
// COMPRESS.CPP
//
//  Source file for ArchiveLib 2.0
//
//  Copyright (c) Greenleaf Software, Inc. 1994-1996
//  All Rights Reserved
//
// CONTENTS
//
//  ALCompressor::operator new()
//  ALCompressor::ALCompressor()
//  ALCompressor::~ALCompressor()
//  deleteALCompressor()
//  ALCompress()
//
// DESCRIPTION
//
//  This file contains the base class functions for the class ALCompress().
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

#include "arclib.h"
#if !defined( AL_IBM )
#pragma hdrstop
#endif

//
// NAME
//
//  ALCompressor::operator new()
//
// PLATFORMS/ENVIRONMENTS
//
//  Windows
//  C++
//
// SHORT DESCRIPTION
//
//  Memory allocation operator needed with DLL.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  void * ALCompressor::operator new( size_t size )
//
// C SYNOPSIS
//
//  None.
//
// VB SYNOPSIS
//
//  None.
//
// DELPHI SYNOPSIS
//
//  None.
//
// ARGUMENTS
//
//  size  :  The number of bytes needed to create a new ALCompressor object.
//
// DESCRIPTION
//
//  When using a DLL, it is easy to create 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 the newly allocated storage area, or 0 if no storage
//  was available.
//
// EXAMPLE
//
//  None.
//
// SEE ALSO
//
// REVISION HISTORY
//
//   May 23, 1994  1.0A  : First release
//
//   February 14, 1996  2.0A : New release

#if defined( AL_BUILDING_DLL )

void AL_DLL_FAR * AL_PROTO
ALCompressor::operator new( size_t size )  /* Tag internal function */
{
    return ::new char[ size ];
}
#endif

//
// NAME
//
//  ALCompressor::ALCompressor()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Construct a compressor object.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALCompressor::ALCompressor( ALCompressionType compression_type_int,
//                              const char *compression_type_string );
//
// C SYNOPSIS
//
//  None.
//
// VB SYNOPSIS
//
//  None.
//
// DELPHI SYNOPSIS
//
//  None.
//
// ARGUMENTS
//
//  compression_type_int    :  An integer used to indicate the compression
//                             type.  This needs to be selected from the
//                             enumerated type defined in ALDEFS.H.  This
//                             value is usually what gets stored in an
//                             archive to indicate what compression type was
//                             used.
//
//  compression_type_string :  A pointer to a C-style string describing the
//                             type of compression.  This isn't used in
//                             any algorithms, it's on hand as a U/I aid.
//
// DESCRIPTION
//
//  This is the base class constructor for Compressor objects.  Since this
//  class has a pure virtual function, you aren't going to be able to
//  call this guy directly.  Instead, it is called from the constructor
//  for guys such as ALGlCompressor and ALPkCompressor.
//
//  All we do here is init a couple of common members, and invoke the
//  constructor for the absolute base class, ALEngine.
//
// RETURNS
//
//  Nothing.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release


AL_PROTO
ALCompressor::ALCompressor( ALCompressionType compression_type_int,  /* Tag public function */
                            const char AL_DLL_FAR *compression_type_string )
  : ALEngine( compression_type_int, compression_type_string )
{
}

//
// NAME
//
//  ALCompressor::~ALCompressor()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++  C  VB Delphi
//
// SHORT DESCRIPTION
//
//  The ALCompressor destructor.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALCompressor::~ALCompressor();
//
// C SYNOPSIS
//
//  void deleteALCompressor( hALCompressor this_object );
//
// VB SYNOPSIS
//
//  Declare Sub deleteALCompressor Lib "AL20LW" (ByVal this_object&)
//
// DELPHI SYNOPSIS
//
//  procedure deleteALCompressor( this_object : hALCompressor );
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  This destructor will be called as the derived class is destroyed, such
//  as ALPkCompressor or ALGlCompressor.  It doesn't have to do anything, so
//  conceivably this function could just be eliminated, and we could use
//  the compiler-generated one.  But, I guess we just don't like to leave
//  anything up to chance.
//
// RETURNS
//
//  Nothing.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

AL_PROTO
ALCompressor::~ALCompressor()  /* Tag public function */
{
}

#if !defined( AL_NO_C )

extern "C" AL_LINKAGE void AL_FUNCTION
deleteALCompressor( hALCompressor this_object )  /* Tag public function */
{
    AL_ASSERT_OBJECT( this_object, ALCompressor, "deleteALCompressor()" );
    delete (ALCompressor *) this_object;
}

#endif

//
// NAME
//
//  ALCompressor::Compress()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++  C  VB  Delphi
//
// SHORT DESCRIPTION
//
//  Compress from an input object to an output object.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  int ALCompressor::Compress( ALStorage &input_object,
//                              ALStorage &output_object );
//
// C SYNOPSIS
//
//  #include "arclib.h"
//
//  int ALCompress( hALCompressor this_object,
//                  hALStorage input,
//                  hALStorage output );
//
// VB SYNOPSIS
//
//  Declare Function ALCompress Lib "AL20LW"
//    (ByVal this_object&, ByVal input&, ByVal output& ) As Integer
//
// DELPHI SYNOPSIS
//
//  function ALCompress( this_object : hALCompressor;
//                       input : hALStorage;
//                       output : hALStorage ) : Integer;
//
// ARGUMENTS
//
//  this_object  :  A reference or pointer to the ALCompressor object that
//                  is going to perform the compression.  Note that the C++
//                  version of this call doesn't have an explicit argument
//                  here, since it has access to 'this' implicitly.
//
//  input        :  A pointer or reference to the input storage object
//                  that is going to be compressed.
//
//  output       :  A pointer or reference to the output object that is
//                  going to receive the compressed data.
//
// DESCRIPTION
//
//  An ALCompressor object only knows how to do one thing, and that is
//  expressed by way of this function.  Compress() takes an input file,
//  and reads until it hits an EOF.  Output bytes are written to the
//  output object in some compressed format.  The exact format is determined
//  by the derived class.  ALCompressor is an abstract base class that
//  can't be instantiated by itself.
//
//  Since the class can't be instantiated by itself, it's kind of bogus
//  to even suggest that ALCompressor::Compress() is a separate function,
//  as I have done here.  In reality, the only thing that really exists
//  here is a C function that can be used to call the virtual function
//  set up by a derived class.
//
// RETURNS
//
//  A success or failure code.  Hopefully AL_SUCCESS, but values less
//  than 0 are possible (as errors.)
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

#if !defined( AL_NO_C )

extern "C" AL_LINKAGE int AL_FUNCTION
ALCompress( hALCompressor this_object, /* Tag public function */
            hALStorage input,
            hALStorage output )
{
    AL_ASSERT_OBJECT( this_object, ALCompressor, "ALCompress" );
    AL_ASSERT_OBJECT( input, ALStorage, "ALCompress" );
    AL_ASSERT_OBJECT( output, ALStorage, "ALCompress" );
    return ( (ALCompressor *) this_object )->Compress( *(ALStorage *) input, *(ALStorage *) output );
}

#endif