FilesExpand file tree

 master

/

RunningLengthWord32.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

135 lines (111 loc) · 3.33 KB

 master

/

RunningLengthWord32.java

Copy path

Top

File metadata and controls

• Code
• Blame

135 lines (111 loc) · 3.33 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

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

package javaewah32;

/*

* Copyright 2009-2012, Daniel Lemire, Cliff Moon, David McIntosh and Robert Becho

* Licensed under APL 2.0.

*/

/**

* Mostly for internal use.

*

* @since 0.5.0

* @author Daniel Lemire

*/

public final class RunningLengthWord32 {

/**

* Instantiates a new running length word.

*

* @param a an array of 32-bit words

* @param p position in the array where the running length word is located.

*/

RunningLengthWord32(final int[] a, final int p) {

this.array = a;

this.position = p;

}

/**

* Gets the number of literal words.

*

* @return the number of literal words

*/

public int getNumberOfLiteralWords() {

return (this.array[this.position] >>> (1 + runninglengthbits));

}

/**

* Gets the running bit.

*

* @return the running bit

*/

public boolean getRunningBit() {

return (this.array[this.position] & 1) != 0;

}

/**

* Gets the running length.

*

* @return the running length

*/

public int getRunningLength() {

return (this.array[this.position] >>> 1) & largestrunninglengthcount;

}

/**

* Sets the number of literal words.

*

* @param number the new number of literal words

*/

public void setNumberOfLiteralWords(final int number) {

this.array[this.position] |= notrunninglengthplusrunningbit;

this.array[this.position] &= (number << (runninglengthbits + 1))

| runninglengthplusrunningbit;

}

/**

* Sets the running bit.

*

* @param b the new running bit

*/

public void setRunningBit(final boolean b) {

if (b)

this.array[this.position] |= 1;

else

this.array[this.position] &= ~1;

}

/**

* Sets the running length.

*

* @param number the new running length

*/

public void setRunningLength(final int number) {

this.array[this.position] |= shiftedlargestrunninglengthcount;

this.array[this.position] &= (number << 1)

| notshiftedlargestrunninglengthcount;

}

/**

* Return the size in uncompressed words represented by

* this running length word.

*

* @return the int

*/

public int size() {

return getRunningLength() + getNumberOfLiteralWords();

}

/*

* @see java.lang.Object#toString()

*/

@Override

public String toString() {

return "running bit = " + getRunningBit() + " running length = "

+ getRunningLength() + " number of lit. words "

+ getNumberOfLiteralWords();

}

/** The array of words. */

public int[] array;

/** The position in array. */

public int position;

/** number of bits dedicated to marking of the running length of clean words */

public static final int runninglengthbits = 16;

private static final int literalbits = 32 - 1 - runninglengthbits;

/** largest number of dirty words in a run. */

public static final int largestliteralcount = (1 << literalbits) - 1;

/** largest number of clean words in a run */

public static final int largestrunninglengthcount = (1 << runninglengthbits) - 1;

private static final int runninglengthplusrunningbit = (1 << (runninglengthbits + 1)) - 1;

private static final int shiftedlargestrunninglengthcount = largestrunninglengthcount << 1;

private static final int notrunninglengthplusrunningbit = ~runninglengthplusrunningbit;

private static final int notshiftedlargestrunninglengthcount = ~shiftedlargestrunninglengthcount;

}