Skip to content

Commit 3c42618

Browse files
KN4CK3RKN4CK3R
committed
Fixed some code smells.
1 parent 823e555 commit 3c42618

17 files changed

+167
-170
lines changed

‎PipeServer/BinaryReader.cpp

+24-24
Original file line numberDiff line numberDiff line change
@@ -13,25 +13,25 @@ bool BinaryReader::ReadBoolean()
1313
return buffer[0] != 0;
1414
}
1515
//---------------------------------------------------------------------------
16-
uint8_t BinaryReader::ReadByte()
16+
uint8_t BinaryReader::ReadByte() const
1717
{
18-
int b = input.ReadByte();
18+
const int b = input.ReadByte();
1919
if (b == -1)
2020
{
2121
throw IOException();
2222
}
23-
return (uint8_t)b;
23+
return static_cast<uint8_t>(b);
2424
}
2525
//---------------------------------------------------------------------------
26-
std::vector<uint8_t> BinaryReader::ReadBytes(int count)
26+
std::vector<uint8_t> BinaryReader::ReadBytes(int count) const
2727
{
2828
std::vector<uint8_t> result(count);
2929
result.resize(count);
3030

3131
int numRead = 0;
3232
do
3333
{
34-
int n = input.Read(result.data(), numRead, count);
34+
const int n = input.Read(result.data(), numRead, count);
3535
if (n == 0)
3636
{
3737
break;
@@ -51,41 +51,41 @@ std::vector<uint8_t> BinaryReader::ReadBytes(int count)
5151
short BinaryReader::ReadInt16()
5252
{
5353
FillBuffer(2);
54-
return (short)(buffer[0] | buffer[1] << 8);
54+
return static_cast<short>(buffer[0] | buffer[1] << 8);
5555
}
5656
//---------------------------------------------------------------------------
5757
unsigned short BinaryReader::ReadUInt16()
5858
{
5959
FillBuffer(2);
60-
return (unsigned short)(buffer[0] | buffer[1] << 8);
60+
return static_cast<unsigned short>(buffer[0] | buffer[1] << 8);
6161
}
6262
//---------------------------------------------------------------------------
6363
int BinaryReader::ReadInt32()
6464
{
6565
FillBuffer(4);
66-
return (int)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
66+
return static_cast<int>(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
6767
}
6868
//---------------------------------------------------------------------------
6969
unsigned int BinaryReader::ReadUInt32()
7070
{
7171
FillBuffer(4);
72-
return (unsigned int)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
72+
return static_cast<unsigned int>(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
7373
}
7474
//---------------------------------------------------------------------------
7575
long long BinaryReader::ReadInt64()
7676
{
7777
FillBuffer(8);
78-
unsigned int lo = (unsigned int)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
79-
unsigned int hi = (unsigned int)(buffer[4] | buffer[5] << 8 | buffer[6] << 16 | buffer[7] << 24);
80-
return (long long)((unsigned long long)hi) << 32 | lo;
78+
const auto lo = static_cast<unsigned int>(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
79+
const auto hi = static_cast<unsigned int>(buffer[4] | buffer[5] << 8 | buffer[6] << 16 | buffer[7] << 24);
80+
return static_cast<long long>(static_cast<unsigned long long>(hi)) << 32 | lo;
8181
}
8282
//---------------------------------------------------------------------------
8383
unsigned long long BinaryReader::ReadUInt64()
8484
{
8585
FillBuffer(8);
86-
unsigned int lo = (unsigned int)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
87-
unsigned int hi = (unsigned int)(buffer[4] | buffer[5] << 8 | buffer[6] << 16 | buffer[7] << 24);
88-
return ((unsigned long long)hi) << 32 | lo;
86+
const auto lo = static_cast<unsigned int>(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24);
87+
const auto hi = static_cast<unsigned int>(buffer[4] | buffer[5] << 8 | buffer[6] << 16 | buffer[7] << 24);
88+
return static_cast<unsigned long long>(hi) << 32 | lo;
8989
}
9090
//---------------------------------------------------------------------------
9191
void* BinaryReader::ReadIntPtr()
@@ -100,20 +100,20 @@ void* BinaryReader::ReadIntPtr()
100100
float BinaryReader::ReadSingle()
101101
{
102102
auto tmp = ReadUInt32();
103-
return *(float*)&tmp;
103+
return *reinterpret_cast<float*>(&tmp);
104104
}
105105
//---------------------------------------------------------------------------
106106
double BinaryReader::ReadDouble()
107107
{
108108
auto tmp = ReadUInt64();
109-
return *(double*)&tmp;
109+
return *reinterpret_cast<double*>(&tmp);
110110
}
111111
//---------------------------------------------------------------------------
112-
std::wstring BinaryReader::ReadString()
112+
std::wstring BinaryReader::ReadString() const
113113
{
114-
const int MaxCharBytesSize = 128;
114+
const auto MaxCharBytesSize = 128;
115115

116-
auto byteLength = Read7BitEncodedInt();
116+
const auto byteLength = Read7BitEncodedInt();
117117
if (byteLength < 0)
118118
{
119119
throw IOException();
@@ -130,9 +130,9 @@ std::wstring BinaryReader::ReadString()
130130
uint8_t charBytes[MaxCharBytesSize];
131131
do
132132
{
133-
auto readLength = (byteLength - currPos) > MaxCharBytesSize ? MaxCharBytesSize : byteLength - currPos;
133+
const auto readLength = (byteLength - currPos) > MaxCharBytesSize ? MaxCharBytesSize : byteLength - currPos;
134134

135-
auto n = input.Read(charBytes, 0, readLength);
135+
const auto n = input.Read(charBytes, 0, readLength);
136136
if (n == 0)
137137
{
138138
throw IOException();
@@ -158,7 +158,7 @@ void BinaryReader::FillBuffer(int numBytes)
158158
{
159159
throw IOException();
160160
}
161-
buffer[0] = (uint8_t)n;
161+
buffer[0] = static_cast<uint8_t>(n);
162162
return;
163163
}
164164

@@ -173,7 +173,7 @@ void BinaryReader::FillBuffer(int numBytes)
173173
} while (bytesRead < numBytes);
174174
}
175175
//---------------------------------------------------------------------------
176-
int BinaryReader::Read7BitEncodedInt()
176+
int BinaryReader::Read7BitEncodedInt() const
177177
{
178178
// Read out an int32 7 bits at a time. The high bit of the
179179
// byte when on means to continue reading more bytes.

‎PipeServer/BinaryReader.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -12,9 +12,9 @@ class BinaryReader
1212

1313
bool ReadBoolean();
1414

15-
uint8_t ReadByte();
15+
uint8_t ReadByte() const;
1616

17-
std::vector<uint8_t> ReadBytes(int count);
17+
std::vector<uint8_t> ReadBytes(int count) const;
1818

1919
short ReadInt16();
2020

@@ -34,12 +34,12 @@ class BinaryReader
3434

3535
double ReadDouble();
3636

37-
std::wstring ReadString();
37+
std::wstring ReadString() const;
3838

3939
private:
4040
void FillBuffer(int numBytes);
4141

42-
int Read7BitEncodedInt();
42+
int Read7BitEncodedInt() const;
4343

4444
Stream& input;
4545
uint8_t buffer[8];

‎PipeServer/BinaryWriter.cpp

+51-51
Original file line numberDiff line numberDiff line change
@@ -9,75 +9,75 @@ BinaryWriter::BinaryWriter(Stream& _output)
99
//---------------------------------------------------------------------------
1010
void BinaryWriter::Write(bool value)
1111
{
12-
buffer[0] = (uint8_t)(value ? 1 : 0);
12+
buffer[0] = static_cast<uint8_t>(value ? 1 : 0);
1313
output.Write(buffer, 0, 1);
1414
}
1515
//---------------------------------------------------------------------------
16-
void BinaryWriter::Write(uint8_t value)
16+
void BinaryWriter::Write(uint8_t value) const
1717
{
1818
output.WriteByte(value);
1919
}
2020
//---------------------------------------------------------------------------
21-
void BinaryWriter::Write(const uint8_t* buffer, int offset, int length)
21+
void BinaryWriter::Write(const uint8_t* buffer, int offset, int length) const
2222
{
2323
output.Write(buffer, 0, length);
2424
}
2525
//---------------------------------------------------------------------------
2626
void BinaryWriter::Write(short value)
2727
{
28-
buffer[0] = (uint8_t)value;
29-
buffer[1] = (uint8_t)(value >> 8);
28+
buffer[0] = static_cast<uint8_t>(value);
29+
buffer[1] = static_cast<uint8_t>(value >> 8);
3030
output.Write(buffer, 0, 2);
3131
}
3232
//---------------------------------------------------------------------------
3333
void BinaryWriter::Write(unsigned short value)
3434
{
35-
buffer[0] = (uint8_t)value;
36-
buffer[1] = (uint8_t)(value >> 8);
35+
buffer[0] = static_cast<uint8_t>(value);
36+
buffer[1] = static_cast<uint8_t>(value >> 8);
3737
output.Write(buffer, 0, 2);
3838
}
3939
//---------------------------------------------------------------------------
4040
void BinaryWriter::Write(int value)
4141
{
42-
buffer[0] = (uint8_t)value;
43-
buffer[1] = (uint8_t)(value >> 8);
44-
buffer[2] = (uint8_t)(value >> 16);
45-
buffer[3] = (uint8_t)(value >> 24);
42+
buffer[0] = static_cast<uint8_t>(value);
43+
buffer[1] = static_cast<uint8_t>(value >> 8);
44+
buffer[2] = static_cast<uint8_t>(value >> 16);
45+
buffer[3] = static_cast<uint8_t>(value >> 24);
4646
output.Write(buffer, 0, 4);
4747
}
4848
//---------------------------------------------------------------------------
4949
void BinaryWriter::Write(unsigned int value)
5050
{
51-
buffer[0] = (uint8_t)value;
52-
buffer[1] = (uint8_t)(value >> 8);
53-
buffer[2] = (uint8_t)(value >> 16);
54-
buffer[3] = (uint8_t)(value >> 24);
51+
buffer[0] = static_cast<uint8_t>(value);
52+
buffer[1] = static_cast<uint8_t>(value >> 8);
53+
buffer[2] = static_cast<uint8_t>(value >> 16);
54+
buffer[3] = static_cast<uint8_t>(value >> 24);
5555
output.Write(buffer, 0, 4);
5656
}
5757
//---------------------------------------------------------------------------
5858
void BinaryWriter::Write(long long value)
5959
{
60-
buffer[0] = (uint8_t)value;
61-
buffer[1] = (uint8_t)(value >> 8);
62-
buffer[2] = (uint8_t)(value >> 16);
63-
buffer[3] = (uint8_t)(value >> 24);
64-
buffer[4] = (uint8_t)(value >> 32);
65-
buffer[5] = (uint8_t)(value >> 40);
66-
buffer[6] = (uint8_t)(value >> 48);
67-
buffer[7] = (uint8_t)(value >> 56);
60+
buffer[0] = static_cast<uint8_t>(value);
61+
buffer[1] = static_cast<uint8_t>(value >> 8);
62+
buffer[2] = static_cast<uint8_t>(value >> 16);
63+
buffer[3] = static_cast<uint8_t>(value >> 24);
64+
buffer[4] = static_cast<uint8_t>(value >> 32);
65+
buffer[5] = static_cast<uint8_t>(value >> 40);
66+
buffer[6] = static_cast<uint8_t>(value >> 48);
67+
buffer[7] = static_cast<uint8_t>(value >> 56);
6868
output.Write(buffer, 0, 8);
6969
}
7070
//---------------------------------------------------------------------------
7171
void BinaryWriter::Write(unsigned long long value)
7272
{
73-
buffer[0] = (uint8_t)value;
74-
buffer[1] = (uint8_t)(value >> 8);
75-
buffer[2] = (uint8_t)(value >> 16);
76-
buffer[3] = (uint8_t)(value >> 24);
77-
buffer[4] = (uint8_t)(value >> 32);
78-
buffer[5] = (uint8_t)(value >> 40);
79-
buffer[6] = (uint8_t)(value >> 48);
80-
buffer[7] = (uint8_t)(value >> 56);
73+
buffer[0] = static_cast<uint8_t>(value);
74+
buffer[1] = static_cast<uint8_t>(value >> 8);
75+
buffer[2] = static_cast<uint8_t>(value >> 16);
76+
buffer[3] = static_cast<uint8_t>(value >> 24);
77+
buffer[4] = static_cast<uint8_t>(value >> 32);
78+
buffer[5] = static_cast<uint8_t>(value >> 40);
79+
buffer[6] = static_cast<uint8_t>(value >> 48);
80+
buffer[7] = static_cast<uint8_t>(value >> 56);
8181
output.Write(buffer, 0, 8);
8282
}
8383
//---------------------------------------------------------------------------
@@ -92,46 +92,46 @@ void BinaryWriter::Write(const void* value)
9292
//---------------------------------------------------------------------------
9393
void BinaryWriter::Write(float value)
9494
{
95-
auto tmp = *(unsigned int*)&value;
96-
buffer[0] = (uint8_t)tmp;
97-
buffer[1] = (uint8_t)(tmp >> 8);
98-
buffer[2] = (uint8_t)(tmp >> 16);
99-
buffer[3] = (uint8_t)(tmp >> 24);
95+
const auto tmp = *reinterpret_cast<unsigned int*>(&value);
96+
buffer[0] = static_cast<uint8_t>(tmp);
97+
buffer[1] = static_cast<uint8_t>(tmp >> 8);
98+
buffer[2] = static_cast<uint8_t>(tmp >> 16);
99+
buffer[3] = static_cast<uint8_t>(tmp >> 24);
100100
output.Write(buffer, 0, 4);
101101
}
102102
//---------------------------------------------------------------------------
103103
void BinaryWriter::Write(double value)
104104
{
105-
auto tmp = *(unsigned long long*)&value;
106-
buffer[0] = (uint8_t)tmp;
107-
buffer[1] = (uint8_t)(tmp >> 8);
108-
buffer[2] = (uint8_t)(tmp >> 16);
109-
buffer[3] = (uint8_t)(tmp >> 24);
110-
buffer[4] = (uint8_t)(tmp >> 32);
111-
buffer[5] = (uint8_t)(tmp >> 40);
112-
buffer[6] = (uint8_t)(tmp >> 48);
113-
buffer[7] = (uint8_t)(tmp >> 56);
105+
const auto tmp = *reinterpret_cast<unsigned long long*>(&value);
106+
buffer[0] = static_cast<uint8_t>(tmp);
107+
buffer[1] = static_cast<uint8_t>(tmp >> 8);
108+
buffer[2] = static_cast<uint8_t>(tmp >> 16);
109+
buffer[3] = static_cast<uint8_t>(tmp >> 24);
110+
buffer[4] = static_cast<uint8_t>(tmp >> 32);
111+
buffer[5] = static_cast<uint8_t>(tmp >> 40);
112+
buffer[6] = static_cast<uint8_t>(tmp >> 48);
113+
buffer[7] = static_cast<uint8_t>(tmp >> 56);
114114
output.Write(buffer, 0, 8);
115115
}
116116
//---------------------------------------------------------------------------
117-
void BinaryWriter::Write(const std::wstring& value)
117+
void BinaryWriter::Write(const std::wstring& value) const
118118
{
119-
int byteLength = (int)value.length() * sizeof(std::wstring::value_type);
119+
const int byteLength = static_cast<int>(value.length()) * sizeof(std::wstring::value_type);
120120
Write7BitEncodedInt(byteLength);
121121

122122
output.Write(reinterpret_cast<const uint8_t*>(value.data()), 0, byteLength);
123123
}
124124
//---------------------------------------------------------------------------
125-
void BinaryWriter::Write7BitEncodedInt(int value)
125+
void BinaryWriter::Write7BitEncodedInt(int value) const
126126
{
127127
// Write out an int32 7 bits at a time. The high bit of the byte,
128128
// when on, tells reader to continue reading more byte.
129-
auto v = (unsigned int)value;
129+
auto v = static_cast<unsigned int>(value);
130130
while (v >= 0x80)
131131
{
132-
Write((uint8_t)(v | 0x80));
132+
Write(static_cast<uint8_t>(v | 0x80));
133133
v >>= 7;
134134
}
135-
Write((uint8_t)v);
135+
Write(static_cast<uint8_t>(v));
136136
}
137137
//---------------------------------------------------------------------------

‎PipeServer/BinaryWriter.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,9 @@ class BinaryWriter
1111

1212
void Write(bool value);
1313

14-
void Write(uint8_t value);
14+
void Write(uint8_t value) const;
1515

16-
void Write(const uint8_t* buffer, int offset, int length);
16+
void Write(const uint8_t* buffer, int offset, int length) const;
1717

1818
void Write(short value);
1919

@@ -33,10 +33,10 @@ class BinaryWriter
3333

3434
void Write(double value);
3535

36-
void Write(const std::wstring& value);
36+
void Write(const std::wstring& value) const;
3737

3838
private:
39-
void Write7BitEncodedInt(int value);
39+
void Write7BitEncodedInt(int value) const;
4040

4141
Stream& output;
4242
uint8_t buffer[8];

0 commit comments

Comments
 (0)