----------------------------------------------------------------

--  ZLib for Ada thick binding.                               --

--                                                            --

--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --

--                                                            --

--  Open source license information is in the zlib.ads file.  --

----------------------------------------------------------------

--  $Id: zlib-streams.adb,v 1.10 2004/05/31 10:53:40 vagul Exp $

with Ada.Unchecked_Deallocation;

package body ZLib.Streams is

   -----------

   -- Close --

   -----------

   procedure Close (Stream : in out Stream_Type) is

      procedure Free is new Ada.Unchecked_Deallocation

         (Stream_Element_Array, Buffer_Access);

   begin

      if Stream.Mode = Out_Stream or Stream.Mode = Duplex then

         --  We should flush the data written by the writer.

         Flush (Stream, Finish);

         Close (Stream.Writer);

      end if;

      if Stream.Mode = In_Stream or Stream.Mode = Duplex then

         Close (Stream.Reader);

         Free (Stream.Buffer);

      end if;

   end Close;

   ------------

   -- Create --

   ------------

   procedure Create

     (Stream            :    out Stream_Type;

      Mode              : in     Stream_Mode;

      Back              : in     Stream_Access;

      Back_Compressed   : in     Boolean;

      Level             : in     Compression_Level := Default_Compression;

      Strategy          : in     Strategy_Type     := Default_Strategy;

      Header            : in     Header_Type       := Default;

      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset

                                    := Default_Buffer_Size;

      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset

                                    := Default_Buffer_Size)

   is

      subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size);

      procedure Init_Filter

         (Filter   : in out Filter_Type;

          Compress : in     Boolean);

      -----------------

      -- Init_Filter --

      -----------------

      procedure Init_Filter

         (Filter   : in out Filter_Type;

          Compress : in     Boolean) is

      begin

         if Compress then

            Deflate_Init

              (Filter, Level, Strategy, Header => Header);

         else

            Inflate_Init (Filter, Header => Header);

         end if;

      end Init_Filter;

   begin

      Stream.Back := Back;

      Stream.Mode := Mode;

      if Mode = Out_Stream or Mode = Duplex then

         Init_Filter (Stream.Writer, Back_Compressed);

         Stream.Buffer_Size := Write_Buffer_Size;

      else

         Stream.Buffer_Size := 0;

      end if;

      if Mode = In_Stream or Mode = Duplex then

         Init_Filter (Stream.Reader, not Back_Compressed);

         Stream.Buffer     := new Buffer_Subtype;

         Stream.Rest_First := Stream.Buffer'Last + 1;

         Stream.Rest_Last  := Stream.Buffer'Last;

      end if;

   end Create;

   -----------

   -- Flush --

   -----------

   procedure Flush

     (Stream : in out Stream_Type;

      Mode   : in     Flush_Mode := Sync_Flush)

   is

      Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size);

      Last   : Stream_Element_Offset;

   begin

      loop

         Flush (Stream.Writer, Buffer, Last, Mode);

         Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last));

         exit when Last < Buffer'Last;

      end loop;

   end Flush;

   -------------

   -- Is_Open --

   -------------

   function Is_Open (Stream : Stream_Type) return Boolean is

   begin

      return Is_Open (Stream.Reader) or else Is_Open (Stream.Writer);

   end Is_Open;

   ----------

   -- Read --

   ----------

   procedure Read

     (Stream : in out Stream_Type;

      Item   :    out Stream_Element_Array;

      Last   :    out Stream_Element_Offset)

   is

      procedure Read

        (Item : out Stream_Element_Array;

         Last : out Stream_Element_Offset);

      ----------

      -- Read --

      ----------

      procedure Read

        (Item : out Stream_Element_Array;

         Last : out Stream_Element_Offset) is

      begin

         Ada.Streams.Read (Stream.Back.all, Item, Last);

      end Read;

      procedure Read is new ZLib.Read

         (Read       => Read,

          Buffer     => Stream.Buffer.all,

          Rest_First => Stream.Rest_First,

          Rest_Last  => Stream.Rest_Last);

   begin

      Read (Stream.Reader, Item, Last);

   end Read;

   -------------------

   -- Read_Total_In --

   -------------------

   function Read_Total_In (Stream : in Stream_Type) return Count is

   begin

      return Total_In (Stream.Reader);

   end Read_Total_In;

   --------------------

   -- Read_Total_Out --

   --------------------

   function Read_Total_Out (Stream : in Stream_Type) return Count is

   begin

      return Total_Out (Stream.Reader);

   end Read_Total_Out;

   -----------

   -- Write --

   -----------

   procedure Write

     (Stream : in out Stream_Type;

      Item   : in     Stream_Element_Array)

   is

      procedure Write (Item : in Stream_Element_Array);

      -----------

      -- Write --

      -----------

      procedure Write (Item : in Stream_Element_Array) is

      begin

         Ada.Streams.Write (Stream.Back.all, Item);

      end Write;

      procedure Write is new ZLib.Write

         (Write       => Write,

          Buffer_Size => Stream.Buffer_Size);

   begin

      Write (Stream.Writer, Item, No_Flush);

   end Write;

   --------------------

   -- Write_Total_In --

   --------------------

   function Write_Total_In (Stream : in Stream_Type) return Count is

   begin

      return Total_In (Stream.Writer);

   end Write_Total_In;

   ---------------------

   -- Write_Total_Out --

   ---------------------

   function Write_Total_Out (Stream : in Stream_Type) return Count is

   begin

      return Total_Out (Stream.Writer);

   end Write_Total_Out;

end ZLib.Streams;