Changeset 1467

Show
Ignore:
Timestamp:
01/25/07 12:34:22
Author:
pvanhoof
Message:

Several little changes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libtinymail-camel/camel-lite/camel/camel-stream-gzip.c

    r1464 r1467  
    3333static ssize_t z_stream_read (CamelStream *stream, char *buffer, size_t n)  
    3434{ 
    35         char *mem = NULL; ssize_t haveread = 0, retval = 0; 
    36         CamelStreamGZip *self = (CamelStreamGZip *) stream; 
    37         z_stream c_stream = * (self->stream); 
    38  
    39         c_stream.next_out = (Bytef *) buffer; 
    40         c_stream.avail_out = n; 
    41  
    42         if (self->mode == CAMEL_STREAM_GZIP_ZIP) 
    43         { 
    44                 mem = g_malloc0 (n); 
     35        ssize_t haveread = 0, retval = 0; 
     36        CamelStreamGZip *self = (CamelStreamGZip *) stream; 
     37        z_stream c_stream = * (self->r_stream); 
     38 
     39        if (self->read_mode == CAMEL_STREAM_GZIP_ZIP) 
     40        { 
     41                char *mem = g_malloc0 (n); 
     42                c_stream.next_out = (Bytef *) buffer; 
     43                c_stream.avail_out = n; 
    4544                haveread = camel_stream_read (self->real, mem, n); 
    4645                c_stream.next_in = (Bytef *) mem; 
     
    4847                deflate (&c_stream, Z_FINISH); 
    4948                retval = n - c_stream.avail_out; 
     49                g_free (mem); 
    5050        } else 
    5151        { 
    52  
    53                 /* TODO */ 
    54  
    55                 int block_size = n / 100; 
     52                int block_size = (n < 1000) ? (n < 10 ? 2 : 10) : n / 100; 
     53                char *mem = g_malloc0 (block_size); 
    5654 
    5755                haveread = block_size; 
    58                 mem = g_malloc0 (block_size); 
    59  
    6056                c_stream.next_out = (Bytef *) buffer; 
    6157                c_stream.avail_out = n; 
     
    6763                        c_stream.avail_in = haveread; 
    6864                        inflate (&c_stream, Z_FINISH); 
    69                         retval += haveread - c_stream.avail_out; 
    7065                } 
    71  
    72         } 
    73  
    74         g_free (mem); 
     66                retval = n - c_stream.avail_out; 
     67                g_free (mem); 
     68        } 
    7569 
    7670        return retval;  
     
    8175{  
    8276        CamelStreamGZip *self = (CamelStreamGZip *) stream; 
    83         z_stream c_stream = * (self->stream); 
    84         char *mem = NULL; 
     77        z_stream c_stream = * (self->w_stream); 
    8578        ssize_t retval = 0; 
    8679 
    87         if (self->mode == CAMEL_STREAM_GZIP_ZIP) 
    88         { 
    89  
    90                 /* TODO */ 
    91  
    92                 mem = g_malloc0 (n); 
     80        if (self->write_mode == CAMEL_STREAM_GZIP_ZIP) 
     81        { 
     82                char *mem = g_malloc0 (n); 
    9383 
    9484                c_stream.next_in  = (Bytef *) buffer; 
    9585                c_stream.avail_in = n; 
    96                 c_stream.next_out = mem; 
     86                c_stream.next_out = (Bytef *) mem; 
    9787                c_stream.avail_out = n; 
    9888 
     
    10292 
    10393                retval = n; 
     94                g_free (mem); 
    10495 
    10596        } else  
    10697        { 
    107                 mem = g_malloc0 (n); 
     98                char *mem = g_malloc0 (n); 
    10899 
    109100                c_stream.next_in = (Bytef *) buffer; 
     
    122113                        c_stream.avail_out = n; 
    123114                } 
    124         } 
    125  
    126         g_free (mem); 
     115                g_free (mem); 
     116        } 
    127117 
    128118        return retval;  
     
    132122{  
    133123        CamelStreamGZip *self = (CamelStreamGZip *) stream; 
    134         char mem[1024]; 
    135         z_stream c_stream = * (self->stream); 
    136  
    137  
    138         if (self->mode != CAMEL_STREAM_GZIP_ZIP) 
    139         { 
    140                 c_stream.next_out = (Bytef *) mem; 
    141                 c_stream.avail_out = 1024; 
    142  
    143                 while (c_stream.avail_in > 0) 
    144                 { 
    145                         inflate (&c_stream, Z_NO_FLUSH); 
    146                         camel_stream_write (self->real, mem, 1024 - c_stream.avail_out); 
    147                         c_stream.next_out = (Bytef *) mem; 
    148                         c_stream.avail_out = 1024; 
    149                 } 
    150                 inflateReset (self->stream); 
    151         } else 
    152                 deflateReset (self->stream); 
    153  
    154124        return camel_stream_flush (self->real);  
    155125} 
     
    158128{  
    159129        CamelStreamGZip *self = (CamelStreamGZip *) stream; 
    160  
    161130        z_stream_flush (stream); 
    162  
    163131        return camel_stream_close (self->real);  
    164132} 
     
    174142        CamelStreamGZip *self = (CamelStreamGZip *) stream; 
    175143 
    176         if (self->mode == CAMEL_STREAM_GZIP_ZIP) 
    177                 deflateReset (self->stream); 
    178         else 
    179                 inflateReset (self->stream); 
     144        if (self->read_mode == CAMEL_STREAM_GZIP_ZIP) 
     145                deflateReset (self->r_stream); 
     146        else 
     147                inflateReset (self->r_stream); 
     148 
     149 
     150        if (self->write_mode == CAMEL_STREAM_GZIP_ZIP) 
     151                deflateReset (self->w_stream); 
     152        else 
     153                inflateReset (self->w_stream); 
     154 
    180155 
    181156        return 0;  
     
    205180        camel_object_unref (CAMEL_OBJECT (self->real)); 
    206181 
    207         if (self->mode == CAMEL_STREAM_GZIP_ZIP) 
    208                 deflateEnd (self->stream); 
    209         else 
    210                 inflateEnd (self->stream); 
    211  
    212         g_free (self->stream); 
     182        if (self->read_mode == CAMEL_STREAM_GZIP_ZIP) 
     183                deflateEnd (self->r_stream); 
     184        else 
     185                inflateEnd (self->r_stream); 
     186 
     187 
     188        if (self->write_mode == CAMEL_STREAM_GZIP_ZIP) 
     189                deflateEnd (self->w_stream); 
     190        else 
     191                inflateEnd (self->w_stream); 
     192 
     193        g_free (self->r_stream); 
     194        g_free (self->w_stream); 
    213195 
    214196        return; 
     
    236218} 
    237219 
     220static int 
     221set_mode (z_stream *stream, int level, int mode) 
     222{ 
     223        int retval; 
     224        if (mode == CAMEL_STREAM_GZIP_ZIP) 
     225                retval = deflateInit2 (stream, level, Z_DEFLATED, -MAX_WBITS,  
     226                        MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY); 
     227        else 
     228                retval = inflateInit2 (stream, -MAX_WBITS); 
     229        return retval; 
     230} 
     231 
    238232CamelStream * 
    239 camel_stream_gzip_new (CamelStream *real, int level, int mode) 
     233camel_stream_gzip_new (CamelStream *real, int level, int read_mode, int write_mode) 
    240234{ 
    241235        CamelStreamGZip *self = (CamelStreamGZip *) camel_object_new (camel_stream_gzip_get_type ()); 
    242236        int retval; 
    243237 
    244         self->stream = g_new0 (z_stream, 1); 
    245         self->level = level; 
    246         self->mode = mode; 
    247  
    248         if (self->mode == CAMEL_STREAM_GZIP_ZIP) 
    249         { 
    250                 retval = deflateInit2 (self->stream, self->level, Z_DEFLATED, -MAX_WBITS,  
    251                         MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY); 
    252  
    253                         if (retval != Z_OK) 
    254                 { 
    255                         camel_object_unref (self); 
    256                         return NULL; 
    257                 } 
    258         } else { 
    259                 retval = inflateInit2 (self->stream, -MAX_WBITS); 
    260                 if (retval != Z_OK) 
    261                 { 
    262                         camel_object_unref (self); 
    263                         return NULL; 
    264                 } 
    265         } 
    266  
    267238        camel_object_ref (CAMEL_OBJECT (real)); 
    268239        self->real = real; 
    269240 
     241        self->r_stream = g_new0 (z_stream, 1); 
     242        self->w_stream = g_new0 (z_stream, 1); 
     243        self->level = level; 
     244        self->read_mode = read_mode; 
     245        self->write_mode = write_mode; 
     246 
     247        retval = set_mode (self->r_stream, level, read_mode); 
     248        if (retval != Z_OK) 
     249        { 
     250                camel_object_unref (self); 
     251                return NULL; 
     252        } 
     253 
     254 
     255        retval = set_mode (self->w_stream, level, write_mode); 
     256        if (retval != Z_OK) 
     257        { 
     258                camel_object_unref (self); 
     259                return NULL; 
     260        } 
     261 
     262 
    270263        return CAMEL_STREAM (self); 
    271264} 
  • trunk/libtinymail-camel/camel-lite/camel/camel-stream-gzip.h

    r1464 r1467  
    4949 
    5050        CamelStream *real; 
    51         z_stream *stream; 
    52         int mode, level; 
     51        z_stream *r_stream, *w_stream; 
     52        int read_mode, write_mode, level; 
    5353}; 
    5454 
     
    5959CamelType camel_stream_gzip_get_type (void); 
    6060 
    61 CamelStream *camel_stream_gzip_new (CamelStream *real, int level, int mode); 
     61CamelStream *camel_stream_gzip_new (CamelStream *real, int level, int read_mode, int write_mode); 
    6262 
    6363#ifdef __cplusplus 
  • trunk/tests/functional/anything.c

    r1464 r1467  
    1717        in = camel_stream_mem_new_with_buffer (TEST, strlen (TEST)); 
    1818 
    19         com = camel_stream_gzip_new (in, 7, CAMEL_STREAM_GZIP_ZIP); 
    20         de = camel_stream_gzip_new (out, 7, CAMEL_STREAM_GZIP_UNZIP); 
     19        com = camel_stream_gzip_new (in, 7, CAMEL_STREAM_GZIP_ZIP, CAMEL_STREAM_GZIP_ZIP); 
     20        de = camel_stream_gzip_new (out, 7, CAMEL_STREAM_GZIP_UNZIP, CAMEL_STREAM_GZIP_UNZIP); 
    2121 
    2222        camel_stream_write_to_stream (com, de); 
  • trunk/tinymail

    • Property svn:ignore changed from tags Makefile.in tinymail .svnignore stamp-h1 config.h .libs .deps Makefile to tny-demoui tags Makefile.in tinymail .svnignore stamp-h1 config.h .libs .deps Makefile
  • trunk/tinymail/.svnignore

    r689 r1467  
     1tny-demoui 
    12tags 
    23Makefile.in 
  • trunk/tinymail/Makefile.am

    r890 r1467  
    1717endif 
    1818 
    19 bin_PROGRAMS = tinymail 
     19bin_PROGRAMS = tny-demoui 
    2020 
    21 tinymail_SOURCES =                            \ 
     21tny_demoui_SOURCES =                          \ 
    2222        tny-main.c                              \ 
    2323        tny-demoui-summary-view.c               \ 
    2424        tny-demoui-summary-view.h 
    2525 
    26 tinymail_LDADD =                                                              \ 
     26tny_demoui_LDADD =                                                            \ 
    2727        $(TINYMAIL_LIBS)                                                        \ 
    2828        $(LIBTINYMAIL_GNOME_DESKTOP_LIBS)                                       \