third_party/lzma/v4_65/files/CPP/7zip/Common/StreamBinder.cpp - Issue 624713003: Keep only base/extractor.[cc|h].

Side by Side Diff: third_party/lzma/v4_65/files/CPP/7zip/Common/StreamBinder.cpp

Issue 624713003: Keep only base/extractor.[cc|h]. (Closed) Base URL: https://chromium.googlesource.com/external/omaha.git@master

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « third_party/lzma/v4_65/files/CPP/7zip/Common/StreamBinder.h ('k') | third_party/lzma/v4_65/files/CPP/7zip/Common/StreamObjects.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // StreamBinder.cpp

2

3 #include "StdAfx.h"

4

5 #include "StreamBinder.h"

6 #include "../../Common/Defs.h"

7 #include "../../Common/MyCom.h"

8

9 using namespace NWindows;

10 using namespace NSynchronization;

11

12 class CSequentialInStreamForBinder:

13 public ISequentialInStream,

14 public CMyUnknownImp

15 {

16 public:

17 MY_UNKNOWN_IMP

18

19 STDMETHOD(Read)(void data, UInt32 size, UInt32 processedSize);

20 private:

21 CStreamBinder *m_StreamBinder;

22 public:

23 ~CSequentialInStreamForBinder() { m_StreamBinder->CloseRead(); }

24 void SetBinder(CStreamBinder *streamBinder) { m_StreamBinder = streamBinder; }

25 };

26

27 STDMETHODIMP CSequentialInStreamForBinder::Read(void data, UInt32 size, UInt32 processedSize)

28 { return m_StreamBinder->Read(data, size, processedSize); }

29

30 class CSequentialOutStreamForBinder:

31 public ISequentialOutStream,

32 public CMyUnknownImp

33 {

34 public:

35 MY_UNKNOWN_IMP

36

37 STDMETHOD(Write)(const void data, UInt32 size, UInt32 processedSize);

38

39 private:

40 CStreamBinder *m_StreamBinder;

41 public:

42 ~CSequentialOutStreamForBinder() { m_StreamBinder->CloseWrite(); }

43 void SetBinder(CStreamBinder *streamBinder) { m_StreamBinder = streamBinder; }

44 };

45

46 STDMETHODIMP CSequentialOutStreamForBinder::Write(const void data, UInt32 size, UInt32 processedSize)

47 { return m_StreamBinder->Write(data, size, processedSize); }

48

49

50 //////////////////////////

51 // CStreamBinder

52 // (_thereAreBytesToReadEvent && _bufferSize == 0) means that stream is finished .

53

54 HRes CStreamBinder::CreateEvents()

55 {

56 RINOK(_allBytesAreWritenEvent.Create(true));

57 RINOK(_thereAreBytesToReadEvent.Create());

58 return _readStreamIsClosedEvent.Create();

59 }

60

61 void CStreamBinder::ReInit()

62 {

63 _thereAreBytesToReadEvent.Reset();

64 _readStreamIsClosedEvent.Reset();

65 ProcessedSize = 0;

66 }

67

68

69

70 void CStreamBinder::CreateStreams(ISequentialInStream **inStream,

71 ISequentialOutStream **outStream)

72 {

73 CSequentialInStreamForBinder *inStreamSpec = new

74 CSequentialInStreamForBinder;

75 CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);

76 inStreamSpec->SetBinder(this);

77 *inStream = inStreamLoc.Detach();

78

79 CSequentialOutStreamForBinder *outStreamSpec = new

80 CSequentialOutStreamForBinder;

81 CMyComPtr<ISequentialOutStream> outStreamLoc(outStreamSpec);

82 outStreamSpec->SetBinder(this);

83 *outStream = outStreamLoc.Detach();

84

85 _buffer = NULL;

86 _bufferSize= 0;

87 ProcessedSize = 0;

88 }

89

90 HRESULT CStreamBinder::Read(void data, UInt32 size, UInt32 processedSize)

91 {

92 UInt32 sizeToRead = size;

93 if (size > 0)

94 {

95 RINOK(_thereAreBytesToReadEvent.Lock());

96 sizeToRead = MyMin(_bufferSize, size);

97 if (_bufferSize > 0)

98 {

99 memcpy(data, _buffer, sizeToRead);

100 _buffer = ((const Byte *)_buffer) + sizeToRead;

101 _bufferSize -= sizeToRead;

102 if (_bufferSize == 0)

103 {

104 _thereAreBytesToReadEvent.Reset();

105 _allBytesAreWritenEvent.Set();

106 }

107 }

108 }

109 if (processedSize != NULL)

110 *processedSize = sizeToRead;

111 ProcessedSize += sizeToRead;

112 return S_OK;

113 }

114

115 void CStreamBinder::CloseRead()

116 {

117 _readStreamIsClosedEvent.Set();

118 }

119

120 HRESULT CStreamBinder::Write(const void data, UInt32 size, UInt32 processedSiz e)

121 {

122 if (size > 0)

123 {

124 _buffer = data;

125 _bufferSize = size;

126 _allBytesAreWritenEvent.Reset();

127 _thereAreBytesToReadEvent.Set();

128

129 HANDLE events[2];

130 events[0] = _allBytesAreWritenEvent;

131 events[1] = _readStreamIsClosedEvent;

132 DWORD waitResult = ::WaitForMultipleObjects(2, events, FALSE, INFINITE);

133 if (waitResult != WAIT_OBJECT_0 + 0)

134 {

135 // ReadingWasClosed = true;

136 return S_FALSE;

137 }

138 // if(!_allBytesAreWritenEvent.Lock())

139 // return E_FAIL;

140 }

141 if (processedSize != NULL)

142 *processedSize = size;

143 return S_OK;

144 }

145

146 void CStreamBinder::CloseWrite()

147 {

148 // _bufferSize must be = 0

149 _thereAreBytesToReadEvent.Set();

150 }

OLD	NEW