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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
#ifndef BLOBSIZE_H
#define BLOBSIZE_H
#include "Runtime/Serialize/TransferFunctions/TransferBase.h"
struct ReduceCopyData;
class BlobSize : public TransferBase
{
private:
typedef OffsetPtr<void*>::offset_type offset_type;
size_t m_Size;
bool m_IgnorePtr;
bool m_HasDebugOffsetPtr;
bool m_Use64Ptr;
int m_TargetPlatform;
std::size_t AlignAddress(std::size_t addr, std::size_t align)
{
return addr + ((~addr + 1U) & (align - 1U));
}
public:
BlobSize (bool hasDebugOffsetPtr, bool use64BitOffsetPtr)
: m_Size (0)
, m_IgnorePtr (false)
, m_HasDebugOffsetPtr (hasDebugOffsetPtr)
, m_Use64Ptr (use64BitOffsetPtr) { }
bool NeedsInstanceIDRemapping () { return m_Flags & kNeedsInstanceIDRemapping; }
int GetFlags () { return m_Flags; }
bool IsWritingGameReleaseData ()
{
return true;
}
bool IsSerializingForGameRelease ()
{
return true;
}
bool IsBuildingTargetPlatform (BuildTargetPlatform platform)
{
if (platform == kBuildAnyPlayerData)
return m_TargetPlatform >= kBuildValidPlayer;
else
return m_TargetPlatform == platform;
}
BuildTargetPlatform GetBuildingTargetPlatform () { return static_cast<BuildTargetPlatform>(m_TargetPlatform); }
template<class T>
void Transfer (T& data, const char* name, TransferMetaFlags metaFlag = kNoTransferFlags);
template<class T>
void TransferWithTypeString (T& data, const char* name, const char* typeName, TransferMetaFlags metaFlag = kNoTransferFlags);
template<class T>
void TransferBasicData (T& data);
template<class T>
void TransferPtr (bool isValidPtr, ReduceCopyData* reduceCopyData);
template<class T>
void TransferSTLStyleArray (T& data, TransferMetaFlags metaFlag = kNoTransferFlags);
template<class T>
static size_t CalculateSize (T& data, bool hasDebugOffsetPtr, bool use64BitOffsetPtr)
{
BlobSize sizer (hasDebugOffsetPtr, use64BitOffsetPtr);
sizer.Transfer(data, "Base");
// size_t size = sizeof(T);
// Assert( sizeof(T) == sizer.m_Size);
return sizer.m_Size;
}
template<class> friend class BlobSizeTransferSTLStyleArrayImpl;
};
template<typename T> class BlobSizeTransferSTLStyleArrayImpl
{
public:
void operator()(T& data, TransferMetaFlags metaFlags, BlobSize& transfer)
{
AssertString ("STL array are not support for BlobWrite");
}
};
template<typename T> class BlobSizeTransferSTLStyleArrayImpl< OffsetPtrArrayTransfer<T> >
{
public:
void operator()(OffsetPtrArrayTransfer<T>& data, TransferMetaFlags metaFlags, BlobSize& transfer)
{
transfer.m_IgnorePtr = false;
}
};
template<typename T, int SIZE> class BlobSizeTransferSTLStyleArrayImpl< StaticArrayTransfer<T, SIZE> >
{
public:
void operator()(StaticArrayTransfer<T, SIZE>& data, TransferMetaFlags metaFlags, BlobSize& transfer)
{
transfer.m_Size = transfer.AlignAddress(transfer.m_Size, ALIGN_OF(T));
transfer.m_Size += sizeof(T)*data.size();
}
};
template<class T> inline
void BlobSize::TransferSTLStyleArray (T& data, TransferMetaFlags metaFlags)
{
BlobSizeTransferSTLStyleArrayImpl<T> transfer;
transfer(data, metaFlags, *this);
}
template<class T> inline
void BlobSize::Transfer (T& data, const char* name, TransferMetaFlags)
{
if (m_IgnorePtr)
{
m_IgnorePtr = false;
return;
}
m_Size = AlignAddress(m_Size, SerializeTraits<T>::GetAlignOf() );
SerializeTraits<T>::Transfer (data, *this);
m_Size = AlignAddress(m_Size, SerializeTraits<T>::GetAlignOf() );
}
template<class T> inline
void BlobSize::TransferWithTypeString (T& data, const char*, const char*, TransferMetaFlags)
{
SerializeTraits<T>::Transfer (data, *this);
}
template<class T> inline
void BlobSize::TransferBasicData (T& srcData)
{
m_Size += sizeof(T);
}
template<class T> inline
void BlobSize::TransferPtr (bool isValidPtr, ReduceCopyData* reduceCopyData)
{
m_Size += m_Use64Ptr ? sizeof(SInt64) : sizeof(SInt32);
if (m_HasDebugOffsetPtr)
m_Size += sizeof(void*);
if (isValidPtr)
m_IgnorePtr = true;
}
#endif
|
