← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.h

  • Committer: mbp at sourcefrog
  • Date: 2005-03-25 01:16:46 UTC
  • Revision ID: mbp@sourcefrog.net-20050325011646-e3f0af5d6bd1190c
- update version string
- put it in bzrlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.h
1
 
/*
2
 
 * delta.h: headers for delta functionality
3
 
 *
4
 
 * Adapted from GIT for Bazaar by
5
 
 *   John Arbash Meinel <john@arbash-meinel.com> (C) 2009
6
 
 *
7
 
 * This code is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU General Public License version 2 as
9
 
 * published by the Free Software Foundation.
10
 
 */
11
 
#ifndef DELTA_H
12
 
#define DELTA_H
13
 
 
14
 
/* opaque object for delta index */
15
 
struct delta_index;
16
 
 
17
 
struct source_info {
18
 
    const void *buf; /* Pointer to the beginning of source data */
19
 
    unsigned long size; /* Total length of source data */
20
 
    unsigned long agg_offset; /* Start of source data as part of the
21
 
                                 aggregate source */
22
 
};
23
 
 
24
 
 
25
 
/* result type for functions that have multiple failure modes */
26
 
typedef enum {
27
 
    DELTA_OK,             /* Success */
28
 
    DELTA_OUT_OF_MEMORY,  /* Could not allocate required memory */
29
 
    DELTA_INDEX_NEEDED,   /* A delta_index must be passed */
30
 
    DELTA_SOURCE_EMPTY,   /* A source_info had no content */
31
 
    DELTA_SOURCE_BAD,     /* A source_info had invalid or corrupt content */
32
 
    DELTA_BUFFER_EMPTY,   /* A buffer pointer and size */
33
 
    DELTA_SIZE_TOO_BIG,   /* Delta data is larger than the max requested */
34
 
} delta_result;
35
 
 
36
 
 
37
 
/*
38
 
 * create_delta_index: compute index data from given buffer
39
 
 *
40
 
 * Returns a delta_result status, when DELTA_OK then *fresh is set to a struct
41
 
 * delta_index that should be passed to subsequent create_delta() calls, or to
42
 
 * free_delta_index().  Other values are a failure, and *fresh is unset.
43
 
 * The given buffer must not be freed nor altered before free_delta_index() is
44
 
 * called. The resultant struct must be freed using free_delta_index().
45
 
 */
46
 
extern delta_result
47
 
create_delta_index(const struct source_info *src,
48
 
                   struct delta_index *old,
49
 
                   struct delta_index **fresh);
50
 
 
51
 
 
52
 
/*
53
 
 * create_delta_index_from_delta: compute index data from given buffer
54
 
 *
55
 
 * Returns a delta_result status, when DELTA_OK then *fresh is set to a struct
56
 
 * delta_index that should be passed to subsequent create_delta() calls, or to
57
 
 * free_delta_index().  Other values are a failure, and *fresh is unset.
58
 
 * The bytes must be in the form of a delta structure, as generated by
59
 
 * create_delta(). The generated index will only index the insert bytes, and
60
 
 * not any of the control structures.
61
 
 */
62
 
extern delta_result
63
 
create_delta_index_from_delta(const struct source_info *delta,
64
 
                              struct delta_index *old,
65
 
                              struct delta_index **fresh);
66
 
/*
67
 
 * free_delta_index: free the index created by create_delta_index()
68
 
 *
69
 
 * Given pointer must be what create_delta_index() returned, or NULL.
70
 
 */
71
 
extern void free_delta_index(struct delta_index *index);
72
 
 
73
 
/*
74
 
 * sizeof_delta_index: returns memory usage of delta index
75
 
 *
76
 
 * Given pointer must be what create_delta_index() returned, or NULL.
77
 
 */
78
 
extern unsigned long sizeof_delta_index(struct delta_index *index);
79
 
 
80
 
/*
81
 
 * create_delta: create a delta from given index for the given buffer
82
 
 *
83
 
 * This function may be called multiple times with different buffers using
84
 
 * the same delta_index pointer.  If max_delta_size is non-zero and the
85
 
 * resulting delta is to be larger than max_delta_size then DELTA_SIZE_TOO_BIG
86
 
 * is returned.  Otherwise on success, DELTA_OK is returned and *delta_data is
87
 
 * set to a new buffer with the delta data and *delta_size is updated with its
88
 
 * size.  That buffer must be freed by the caller.
89
 
 */
90
 
extern delta_result
91
 
create_delta(const struct delta_index *index,
92
 
             const void *buf, unsigned long bufsize,
93
 
             unsigned long *delta_size, unsigned long max_delta_size,
94
 
             void **delta_data);
95
 
 
96
 
/* the smallest possible delta size is 3 bytes
97
 
 * Target size, Copy command, Copy length
98
 
 */
99
 
#define DELTA_SIZE_MIN  3
100
 
 
101
 
/*
102
 
 * This must be called twice on the delta data buffer, first to get the
103
 
 * expected source buffer size, and again to get the target buffer size.
104
 
 */
105
 
static unsigned long
106
 
get_delta_hdr_size(unsigned char **datap, const unsigned char *top)
107
 
{
108
 
    unsigned char *data = *datap;
109
 
    unsigned char cmd;
110
 
    unsigned long size = 0;
111
 
    int i = 0;
112
 
    do {
113
 
        cmd = *data++;
114
 
        size |= (cmd & ~0x80) << i;
115
 
        i += 7;
116
 
    } while (cmd & 0x80 && data < top);
117
 
    *datap = data;
118
 
    return size;
119
 
}
120
 
 
121
 
#endif