← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to delta.h

  • Committer: John Arbash Meinel
  • Date: 2009-03-03 16:31:07 UTC
  • mto: (0.17.31 trunk)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090303163107-l4j0114btw2efmjp
Change the code around again.

This time, the information about sources is maintained in the DeltaIndex object.
And we pass that info down into create_delta_index, et al.

Next step is to actually combine the delta indexes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
delta.h
6
6
/* opaque object for delta index */
7
7
struct delta_index;
8
8
 
 
9
struct source_info {
 
10
        const void *buf; /* Pointer to the beginning of source data */
 
11
        unsigned long size; /* Total length of source data */
 
12
        unsigned long agg_offset; /* Start of source data as part of the
 
13
                                                                 aggregate source */
 
14
};
 
15
 
9
16
/*
10
17
 * create_delta_index: compute index data from given buffer
11
18
 *
16
23
 * using free_delta_index().
17
24
 */
18
25
extern struct delta_index *
19
 
create_delta_index(const void *buf, unsigned long bufsize,
20
 
                   unsigned long agg_src_offset);
 
26
create_delta_index(const struct source_info *src);
21
27
 
22
28
/*
23
29
 * free_delta_index: free the index created by create_delta_index()
45
51
 */
46
52
extern void *
47
53
create_delta(struct delta_index **indexes,
48
 
         unsigned int num_indexes,
49
 
             const void *buf, unsigned long bufsize,
50
 
             unsigned long *delta_size, unsigned long max_delta_size);
51
 
 
52
 
/*
53
 
 * diff_delta: create a delta from source buffer to target buffer
54
 
 *
55
 
 * If max_delta_size is non-zero and the resulting delta is to be larger
56
 
 * than max_delta_size then NULL is returned.  On success, a non-NULL
57
 
 * pointer to the buffer with the delta data is returned and *delta_size is
58
 
 * updated with its size.  The returned buffer must be freed by the caller.
59
 
 */
60
 
static inline void *
61
 
diff_delta(const void *src_buf, unsigned long src_bufsize,
62
 
           const void *trg_buf, unsigned long trg_bufsize,
63
 
           unsigned long *delta_size, unsigned long max_delta_size)
64
 
{
65
 
        struct delta_index *index = create_delta_index(src_buf, src_bufsize, 0);
66
 
        if (index) {
67
 
                void *delta = create_delta(&index, 1, trg_buf, trg_bufsize,
68
 
                                           delta_size, max_delta_size);
69
 
                free_delta_index(index);
70
 
                return delta;
71
 
        }
72
 
        return NULL;
73
 
}
74
 
 
75
 
/*
76
 
 * patch_delta: recreate target buffer given source buffer and delta data
77
 
 *
78
 
 * On success, a non-NULL pointer to the target buffer is returned and
79
 
 * *trg_bufsize is updated with its size.  On failure a NULL pointer is
80
 
 * returned.  The returned buffer must be freed by the caller.
81
 
 */
82
 
extern void *patch_delta(const void *src_buf, unsigned long src_size,
83
 
                         const void *delta_buf, unsigned long delta_size,
84
 
                         unsigned long *dst_size);
 
54
                 unsigned int num_indexes,
 
55
                 const void *buf, unsigned long bufsize,
 
56
                 unsigned long *delta_size, unsigned long max_delta_size);
85
57
 
86
58
/* the smallest possible delta size is 4 bytes */
87
 
#define DELTA_SIZE_MIN  4
 
59
#define DELTA_SIZE_MIN  4
88
60
 
89
61
/*
90
62
 * This must be called twice on the delta data buffer, first to get the
91
63
 * expected source buffer size, and again to get the target buffer size.
92
64
 */
93
65
static inline unsigned long get_delta_hdr_size(const unsigned char **datap,
94
 
                                               const unsigned char *top)
 
66
                                                   const unsigned char *top)
95
67
{
96
68
        const unsigned char *data = *datap;
97
69
        unsigned char cmd;