NewLife
/
SmartOS
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Array调整字段顺序，节省4字节内存

This commit is contained in:
大石头X2 2017-03-02 12:07:15 +08:00
parent ad3a770e21
commit 53134a0690
2 changed files with 70 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Core/Array.h
View File

@ -59,10 +59,10 @@ public:
#endif
protected:
int _Capacity; // 最大个数。非字节数
bool _needFree; // 是否需要释放
bool _canWrite; // 是否可写
ushort _Size; // 单个元素大小。字节
byte _Size; // 单个元素大小。字节
int _Capacity; // 最大个数。非字节数
void Init();
void move(Array& rval);

149
Core/Buffer.cpp
View File

@ -1,7 +1,7 @@
#if defined(__CC_ARM)
#include <string.h>
#include <string.h>
#else
#include <cstring>
#include <cstring>
#endif
#include "_Core.h"
@ -13,8 +13,8 @@
Buffer::Buffer(void* ptr, int len)
{
_Arr = (char*)ptr;
_Length = len;
_Arr = (char*)ptr;
_Length = len;
}
/*Buffer::Buffer(const Buffer& buf)
@ -29,16 +29,16 @@ Buffer::Buffer(Buffer&& rval)
void Buffer::move(Buffer& rval)
{
_Arr = rval._Arr;
_Length = rval._Length;
_Arr = rval._Arr;
_Length = rval._Length;
rval._Arr = nullptr;
rval._Length = 0;
rval._Arr = nullptr;
rval._Length = 0;
}
Buffer& Buffer::operator = (const Buffer& rhs)
{
if(!SetLength(rhs.Length())) assert(false, "赋值操作无法扩容");
if (!SetLength(rhs.Length())) assert(false, "赋值操作无法扩容");
Copy(rhs, 0);
@ -47,7 +47,7 @@ Buffer& Buffer::operator = (const Buffer& rhs)
Buffer& Buffer::operator = (const void* ptr)
{
if(ptr) Copy(0, ptr, -1);
if (ptr) Copy(0, ptr, -1);
return *this;
}
@ -62,9 +62,9 @@ Buffer& Buffer::operator = (Buffer&& rval)
// 设置指定位置的值，长度不足时自动扩容
bool Buffer::SetAt(int index, byte value)
{
if(index >= _Length && !SetLength(index + 1)) return false;
if (index >= _Length && !SetLength(index + 1)) return false;
_Arr[index] = value;
_Arr[index] = value;
return true;
}
@ -91,7 +91,7 @@ byte& Buffer::operator[](int i)
// 设置数组长度。容量足够则缩小Length，否则失败。子类可以扩展以实现自动扩容
bool Buffer::SetLength(int len)
{
if(len > _Length) return false;
if (len > _Length) return false;
_Length = len;
@ -118,18 +118,18 @@ void Buffer::Zero(void* dest, int len)
// 拷贝数据，默认-1长度表示当前长度
int Buffer::Copy(int destIndex, const void* src, int len)
{
if(!src) return 0;
if (!src) return 0;
// 自己有缓冲区才能拷贝
if(!_Arr || !_Length) return 0;
if (!_Arr || !_Length) return 0;
int remain = _Length - destIndex;
int remain = _Length - destIndex;
// 如果没有指明长度，则拷贝起始位置之后的剩余部分
if(len < 0 )
if (len < 0)
{
// 不指定长度，又没有剩余量，无法拷贝
if(remain <= 0)
if (remain <= 0)
{
debug_printf("Buffer::Copy (0x%p, %d) <= (%d, 0x%p, %d) \r\n", _Arr, _Length, destIndex, src, len);
assert(false, "Buffer::Copy 未指明要拷贝的长度");
@ -137,29 +137,29 @@ int Buffer::Copy(int destIndex, const void* src, int len)
return 0;
}
len = remain;
len = remain;
}
else if(len > remain)
else if (len > remain)
{
// 要拷贝进来的数据超过内存大小，给子类尝试扩容，如果扩容失败，则只拷贝没有超长的那一部分
// 子类可能在这里扩容
if(!SetLength(destIndex + len))
if (!SetLength(destIndex + len))
{
debug_printf("Buffer::Copy (0x%p, %d) <= (%d, 0x%p, %d) \r\n", _Arr, _Length, destIndex, src, len);
assert(false, "Buffer::Copy 缓冲区太小");
len = remain;
len = remain;
}
}
// 放到这里判断，前面有可能自动扩容
if(!_Arr) return 0;
if (!_Arr) return 0;
// 自我拷贝，跳过
if(_Arr + destIndex == src) return len;
if (_Arr + destIndex == src) return len;
// 拷贝数据
if(len) memmove((byte*)_Arr + destIndex, (byte*)src, len);
if (len) memmove((byte*)_Arr + destIndex, (byte*)src, len);
return len;
}
@ -167,12 +167,12 @@ int Buffer::Copy(int destIndex, const void* src, int len)
// 拷贝数据，默认-1长度表示两者最小长度
int Buffer::Copy(int destIndex, const Buffer& src, int srcIndex, int len)
{
if(len < 0 ) len = _Length - destIndex;
if (len < 0) len = _Length - destIndex;
// 允许自身拷贝
// 源数据的实际长度可能跟要拷贝的长度不一致
int remain = src._Length - srcIndex;
if(len > remain) len = remain;
int remain = src._Length - srcIndex;
if (len > remain) len = remain;
//if(len <= 0) return 0;
return Copy(destIndex, (byte*)src._Arr + srcIndex, len);
@ -186,17 +186,17 @@ int Buffer::Copy(const Buffer& src, int destIndex)
// 把数据复制到目标缓冲区，默认-1长度表示当前长度
int Buffer::CopyTo(int srcIndex, void* data, int len) const
{
if(!_Arr || !data) return 0;
if (!_Arr || !data) return 0;
int remain = _Length - srcIndex;
if(remain <= 0) return 0;
int remain = _Length - srcIndex;
if (remain <= 0) return 0;
if(len < 0 || len > remain) len = remain;
if (len < 0 || len > remain) len = remain;
// 拷贝数据
if(len)
if (len)
{
if(data != (byte*)_Arr + srcIndex)
if (data != (byte*)_Arr + srcIndex)
memmove((byte*)data, (byte*)_Arr + srcIndex, len);
}
@ -206,14 +206,14 @@ int Buffer::CopyTo(int srcIndex, void* data, int len) const
// 用指定字节设置初始化一个区域
int Buffer::Set(byte item, int index, int len)
{
if(!_Arr || len == 0) return 0;
if (!_Arr || len == 0) return 0;
int remain = _Length - index;
if(remain <= 0) return 0;
int remain = _Length - index;
if (remain <= 0) return 0;
if(len < 0 || len > remain) len = remain;
if (len < 0 || len > remain) len = remain;
if(len) memset((byte*)_Arr + index, item, len);
if (len) memset((byte*)_Arr + index, item, len);
return len;
}
@ -229,51 +229,38 @@ Buffer Buffer::Sub(int index, int len)
{
assert(index >= 0, "index >= 0");
assert(index < _Length, "index < _Length");
if(len < 0) len = _Length - index;
if (len < 0) len = _Length - index;
assert(index + len <= _Length, "len <= _Length");
return Buffer((byte*)_Arr + index, len);
/*// 预留子类自动扩容
Buffer bs((byte*)_Arr + index, 0);
// 如果不支持自动扩容，这里会失败
if(!bs.SetLength(len)) bs._Length = len;
return false;*/
}
const Buffer Buffer::Sub(int index, int len) const
{
assert(index >= 0, "index >= 0");
if(len < 0) len = _Length - index;
if (len < 0) len = _Length - index;
#if DEBUG
if(index + len > _Length) debug_printf("Buffer::Sub (%d, %d) > %d \r\n", index, len, _Length);
if (index + len > _Length) debug_printf("Buffer::Sub (%d, %d) > %d \r\n", index, len, _Length);
#endif
//assert(index <= _Length, "index < _Length");
assert(index + len <= _Length, "index + len <= _Length");
return Buffer((byte*)_Arr + index, len);
/*// 预留子类自动扩容
Buffer bs((byte*)_Arr + index, 0);
// 如果不支持自动扩容，这里会失败
if(!bs.SetLength(len)) bs._Length = len;
return false;*/
}
// 显示十六进制数据，指定分隔字符
String& Buffer::ToHex(String& str, char sep, int newLine) const
{
auto buf = GetBuffer();
// 拼接在字符串后面
for(int i=0; i < Length(); i++, buf++)
for (int i = 0; i < Length(); i++, buf++)
{
if(i)
if (i)
{
if(newLine > 0 && i % newLine == 0)
if (newLine > 0 && i % newLine == 0)
str += "\r\n";
else if(sep != '\0')
else if (sep != '\0')
str += sep;
}
@ -298,7 +285,7 @@ ushort Buffer::ToUInt16() const
{
auto p = GetBuffer();
// 字节对齐时才能之前转为目标整数
if(((int)p & 0x01) == 0) return *(ushort*)p;
if (((int)p & 0x01) == 0) return *(ushort*)p;
return p[0] | (p[1] << 8);
}
@ -307,7 +294,7 @@ uint Buffer::ToUInt32() const
{
auto p = GetBuffer();
// 字节对齐时才能之前转为目标整数
if(((int)p & 0x03) == 0) return *(uint*)p;
if (((int)p & 0x03) == 0) return *(uint*)p;
return p[0] | (p[1] << 8) | (p[2] << 0x10) | (p[3] << 0x18);
}
@ -316,7 +303,7 @@ UInt64 Buffer::ToUInt64() const
{
auto p = GetBuffer();
// 字节对齐时才能之前转为目标整数
if(((int)p & 0x07) == 0) return *(UInt64*)p;
if (((int)p & 0x07) == 0) return *(UInt64*)p;
uint n1 = p[0] | (p[1] << 8) | (p[2] << 0x10) | (p[3] << 0x18);
p += 4;
@ -369,20 +356,20 @@ int Buffer::CompareTo(const Buffer& bs) const
int Buffer::CompareTo(const void* ptr, int len) const
{
if(len < 0) len = _Length;
if (len < 0) len = _Length;
// 同一个指针，长度决定大小
if(_Arr == ptr) return _Length - len;
if (_Arr == ptr) return _Length - len;
// 以最短长度来比较
int count = _Length;
if(count > len) count = len;
int count = _Length;
if (count > len) count = len;
// 遍历每一个字符
for(cstring p1=_Arr, p2=(cstring)ptr; count>0; count--, p1++, p2++)
for (cstring p1 = _Arr, p2 = (cstring)ptr; count > 0; count--, p1++, p2++)
{
int n = *p1 - *p2;
if(n) return n;
int n = *p1 - *p2;
if (n) return n;
}
// 判断剩余长度，以此决定大小
@ -391,34 +378,34 @@ int Buffer::CompareTo(const void* ptr, int len) const
bool operator == (const Buffer& bs1, const Buffer& bs2)
{
if(bs1._Arr == bs2._Arr) return true;
if(!bs1._Arr || !bs2._Arr) return false;
if(bs1.Length() != bs2.Length()) return false;
if (bs1._Arr == bs2._Arr) return true;
if (!bs1._Arr || !bs2._Arr) return false;
if (bs1.Length() != bs2.Length()) return false;
return bs1.CompareTo(bs2) == 0;
}
bool operator == (const Buffer& bs1, const void* ptr)
{
if(bs1._Arr == ptr) return true;
if(!bs1._Arr || !ptr) return false;
if (bs1._Arr == ptr) return true;
if (!bs1._Arr || !ptr) return false;
return bs1.CompareTo(ptr) == 0;
}
bool operator != (const Buffer& bs1, const Buffer& bs2)
{
if(bs1._Arr == bs2._Arr) return false;
if(!bs1._Arr || !bs2._Arr) return true;
if(bs1.Length() != bs2.Length()) return true;
if (bs1._Arr == bs2._Arr) return false;
if (!bs1._Arr || !bs2._Arr) return true;
if (bs1.Length() != bs2.Length()) return true;
return bs1.CompareTo(bs2) != 0;
}
bool operator != (const Buffer& bs1, const void* ptr)
{
if(bs1._Arr == ptr) return false;
if(!bs1._Arr || !ptr) return true;
if (bs1._Arr == ptr) return false;
if (!bs1._Arr || !ptr) return true;
return bs1.CompareTo(ptr) != 0;
}
@ -428,6 +415,6 @@ bool operator != (const Buffer& bs1, const void* ptr)
// 打包一个指针和长度指定的数据区
void BufferRef::Set(void* ptr, int len)
{
_Arr = (char*)ptr;
_Length = len;
_Arr = (char*)ptr;
_Length = len;
}