FilesExpand file tree

development

/

delta.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

114 lines (103 loc) · 3.54 KB

development

/

delta.h

Copy path

Top

File metadata and controls

• Code
• Blame

114 lines (103 loc) · 3.54 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

/*

* diff-delta code taken from git.git. See diff-delta.c for details.

*

*/

#ifndef INCLUDE_git_delta_h__

#define INCLUDE_git_delta_h__

#include "common.h"

/* opaque object for delta index */

struct git_delta_index;

/*

* create_delta_index: compute index data from given buffer

*

* This returns a pointer to a struct delta_index that should be passed to

* subsequent create_delta() calls, or to free_delta_index(). A NULL pointer

* is returned on failure. The given buffer must not be freed nor altered

* before free_delta_index() is called. The returned pointer must be freed

* using free_delta_index().

*/

extern struct git_delta_index *

git_delta_create_index(const void *buf, unsigned long bufsize);

/*

* free_delta_index: free the index created by create_delta_index()

*

* Given pointer must be what create_delta_index() returned, or NULL.

*/

extern void git_delta_free_index(struct git_delta_index *index);

/*

* sizeof_delta_index: returns memory usage of delta index

*

* Given pointer must be what create_delta_index() returned, or NULL.

*/

extern unsigned long git_delta_sizeof_index(struct git_delta_index *index);

/*

* create_delta: create a delta from given index for the given buffer

*

* This function may be called multiple times with different buffers using

* the same delta_index pointer. If max_delta_size is non-zero and the

* resulting delta is to be larger than max_delta_size then NULL is returned.

* On success, a non-NULL pointer to the buffer with the delta data is

* returned and *delta_size is updated with its size. The returned buffer

* must be freed by the caller.

*/

extern void *git_delta_create(

const struct git_delta_index *index,

const void *buf,

unsigned long bufsize,

unsigned long *delta_size,

unsigned long max_delta_size);

/*

* diff_delta: create a delta from source buffer to target buffer

*

* If max_delta_size is non-zero and the resulting delta is to be larger

* than max_delta_size then NULL is returned. On success, a non-NULL

* pointer to the buffer with the delta data is returned and *delta_size is

* updated with its size. The returned buffer must be freed by the caller.

*/

GIT_INLINE(void *) git_delta(

const void *src_buf, unsigned long src_bufsize,

const void *trg_buf, unsigned long trg_bufsize,

unsigned long *delta_size,

unsigned long max_delta_size)

{

struct git_delta_index *index = git_delta_create_index(src_buf, src_bufsize);

if (index) {

void *delta = git_delta_create(

index, trg_buf, trg_bufsize, delta_size, max_delta_size);

git_delta_free_index(index);

return delta;

}

return NULL;

}

/*

* patch_delta: recreate target buffer given source buffer and delta data

*

* On success, a non-NULL pointer to the target buffer is returned and

* *trg_bufsize is updated with its size. On failure a NULL pointer is

* returned. The returned buffer must be freed by the caller.

*/

extern void *git_delta_patch(

const void *src_buf, unsigned long src_size,

const void *delta_buf, unsigned long delta_size,

unsigned long *dst_size);

/* the smallest possible delta size is 4 bytes */

#define GIT_DELTA_SIZE_MIN 4

/*

* This must be called twice on the delta data buffer, first to get the

* expected source buffer size, and again to get the target buffer size.

*/

GIT_INLINE(unsigned long) git_delta_get_hdr_size(

const unsigned char **datap, const unsigned char *top)

{

const unsigned char *data = *datap;

unsigned long cmd, size = 0;

int i = 0;

do {

cmd = *data++;

size |= (cmd & 0x7f) << i;

i += 7;

} while (cmd & 0x80 && data < top);

*datap = data;

return size;

}

#endif