/************************************************************************************
函数名称：
bool CField::LoadDataFromBuffer(LPBYTE& lpIndicate, LPBYTE& lpData)
功能说明：虚函數,读取一条记录某一字段的数据,可以用来读取值标签.
详细解释：1.子类实现.
出入参数：
[in]: 1.lpIndicate:指示字节地址.
2.lpData :数据地址.
[out]:1.lpIndicate:下一数据块的指示字节地址.
2.lpData :下一数据块的数据地址.
返回类型：bool
制作：YTLI 2002/07/12
修改:
************************************************************************************/
void CField::LoadDataFromBuffer( LPBYTE& lpData)
{
if(m_pValue==NULL)
{//旧版本
if(m_nNextModifyField == -1)
{
NewData();
LoadDataFromBuffer(lpData);
DeleteData();
}
else
{
if(m_pFields->IsConvertToLastVersion(this))
{
NewData();
LoadDataFromBuffer(lpData);
CField* pNewField = m_pFields->m_FieldVersion.GetFieldByAbsolutePos(m_nNextModifyField);
pNewField->ConvertToCurField(this);
DeleteData();
}
}
}
else
{//当前最新
if (GetFieldType() == fString)
{
FieldString* pStr = (FieldString*)m_pValue;
char *pBuf = new char[m_nWidth+2];
memset(pBuf,0,m_nWidth+2);
memcpy(pBuf,lpData,m_nWidth);
*pStr= pBuf;
/*
char* lpstr = pStr->GetBuffer(m_nWidth+2);
memcpy(lpstr,lpData,m_nWidth);
*(lpstr+m_nWidth)= 0;
*(lpstr+m_nWidth+1)= 0;
pStr->ReleaseBuffer();
*/
//pStr->TrimLeft();//,左边空格保留
pStr->TrimRight();
lpData = lpData + Align4(m_nWidth);
}
else
{
memcpy( &*((FieldNUM *)m_pValue), lpData, sizeof(FieldNUM) ); //ytli Modify 2002/09/04
lpData = lpData + sizeof(FieldNUM);
}
}
}
TSharedPtr<FGraphNodeClassNode> FGraphNodeClassHelper::CreateClassDataNode(const class FAssetData& AssetData)
{
TSharedPtr<FGraphNodeClassNode> Node;
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass");
if (GeneratedClassname && ParentClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
FString AssetParentClassName = *ParentClassname;
UObject* Outer2(NULL);
ResolveName(Outer2, AssetParentClassName, false, false);
Node = MakeShareable(new FGraphNodeClassNode);
Node->ParentClassName = AssetParentClassName;
UObject* AssetOb = AssetData.IsAssetLoaded() ? AssetData.GetAsset() : NULL;
UBlueprint* AssetBP = Cast<UBlueprint>(AssetOb);
UClass* AssetClass = AssetBP ? *AssetBP->GeneratedClass : AssetOb ? AssetOb->GetClass() : NULL;
FGraphNodeClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName, AssetClass);
Node->Data = NewData;
}
return Node;
}
void CECTag::InitInt(uint64 data)
{
if (data <= 0xFF) {
m_dataType = EC_TAGTYPE_UINT8;
m_dataLen = 1;
} else if (data <= 0xFFFF) {
m_dataType = EC_TAGTYPE_UINT16;
m_dataLen = 2;
} else if (data <= 0xFFFFFFFF) {
m_dataType = EC_TAGTYPE_UINT32;
m_dataLen = 4;
} else {
m_dataType = EC_TAGTYPE_UINT64;
m_dataLen = 8;
}
NewData();
switch (m_dataType) {
case EC_TAGTYPE_UINT8:
PokeUInt8( m_tagData, (uint8) data );
break;
case EC_TAGTYPE_UINT16:
PokeUInt16( m_tagData, wxUINT16_SWAP_ALWAYS((uint16) data ));
break;
case EC_TAGTYPE_UINT32:
PokeUInt32( m_tagData, wxUINT32_SWAP_ALWAYS((uint32) data ));
break;
case EC_TAGTYPE_UINT64:
PokeUInt64( m_tagData, wxUINT64_SWAP_ALWAYS(data) );
break;
}
}
TSharedPtr<FClassDataNode> FClassBrowseHelper::CreateClassDataNode(const class FAssetData& AssetData)
{
TSharedPtr<FClassDataNode> Node;
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass");
if (GeneratedClassname && ParentClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
FString AssetParentClassName = *ParentClassname;
UObject* Outer2(NULL);
ResolveName(Outer2, AssetParentClassName, false, false);
Node = MakeShareable(new FClassDataNode);
Node->ParentClassName = AssetParentClassName;
FClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName);
Node->Data = NewData;
}
return Node;
}
PeerSocket::PeerSocket(QTcpSocket *_client)
{
client=_client;
client->setSocketOption(QAbstractSocket::KeepAliveOption,QVariant(true));
connect(client,SIGNAL(readyRead()),this,SLOT(NewData()));
connect(client,SIGNAL(disconnected()),this,SLOT(NoRespond()));
}
void Acc_t::Task() {
if (!IEnabled) return;
if (!Delay.Elapsed(&CheckTimer, 108)) return;
if(klGpioIsSetByN(GPIOB, 5)) { // IRQ occured
Uart.Printf("Irq\r");
IClearIrq();
IsTriggered = true;
Delay.Reset(&EvtTimer);
}
#ifdef ACC_ACCELERATIONS_NEEDED
if(NewData()) Uart.Printf("X: %i; Y: %i; Z: %i\r", Accelerations.xMSB, Accelerations.yMSB, Accelerations.zMSB);
ReadAccelerations();
#endif
// Handle event
if (IsTriggered) {
if (!IsHandled) {
EvtTrigger();
IsHandled = true;
}
if (Delay.Elapsed(&EvtTimer, Delay_ms)) {
// Time to shutdown
IsTriggered = false;
IsHandled = false;
EvtNoTrigger();
}
}
}
bool CECTag::ReadFromSocket(CECSocket& socket)
{
ec_tagname_t tmp_tagName;
if (!socket.ReadNumber(&tmp_tagName, sizeof(ec_tagname_t))) {
return false;
}
m_tagName = tmp_tagName >> 1;
bool hasChildren = (tmp_tagName & 0x01) != 0;
if (!socket.ReadNumber(&m_dataType, sizeof(ec_tagtype_t))) {
return false;
}
if (!socket.ReadNumber(&m_dataLen, sizeof(ec_taglen_t))) {
return false;
}
if (hasChildren && !ReadChildren(socket)) {
return false;
}
unsigned int tmp_len = m_dataLen;
m_dataLen = 0;
m_dataLen = tmp_len - GetTagLen();
if (m_dataLen > 0) {
NewData();
if (!socket.ReadBuffer(m_tagData, m_dataLen)) {
return false;
}
} else {
m_tagData = NULL;
}
return true;
}
void CECTag::InitInt(uint64 data)
{
if (data <= 0xFF) {
m_dataType = EC_TAGTYPE_UINT8;
m_dataLen = 1;
} else if (data <= 0xFFFF) {
m_dataType = EC_TAGTYPE_UINT16;
m_dataLen = 2;
} else if (data <= 0xFFFFFFFF) {
m_dataType = EC_TAGTYPE_UINT32;
m_dataLen = 4;
} else {
m_dataType = EC_TAGTYPE_UINT64;
m_dataLen = 8;
}
NewData();
switch (m_dataType) {
case EC_TAGTYPE_UINT8:
PokeUInt8( m_tagData, (uint8) data );
break;
case EC_TAGTYPE_UINT16:
RawPokeUInt16( m_tagData, ENDIAN_HTONS((uint16) data ));
break;
case EC_TAGTYPE_UINT32:
RawPokeUInt32( m_tagData, ENDIAN_HTONL((uint32) data ));
break;
case EC_TAGTYPE_UINT64:
RawPokeUInt64( m_tagData, ENDIAN_HTONLL(data) );
break;
}
}
GLYPH_CHANGED_TYPE IDataContainer::AddData(DataObjectPtr dop)
{
GLYPH_CHANGED_TYPE change = GLYPH_CHANGED_TYPE_NONE;
MARKET_DATA_TYPE datatype = (MARKET_DATA_TYPE)*(int*)(dop->GetData());
if (NewData(dop)) {
//TCHAR name[MAX_PATH];
//CChineseCodeLib::Gb2312ToUnicode(name, MAX_PATH, _name);
//MYTRACE(L"container name is %s\n", name);
//calculators
for (CalConstIter iter = _cals.begin(); iter != _cals.end(); iter++) {
(*iter)->NewData(this, datatype);
}
//canvases
for (DataCanvasArray::const_iterator iter = _canvases.begin(); iter != _canvases.end(); iter++) {
GLYPH_CHANGED_TYPE c = (*iter)->NewData(this, datatype);
change = (GLYPH_CHANGED_TYPE)((int)change | (int)c);
}
//data graphs
for (DataGraphConstIter iter = _dgraph.begin(); iter != _dgraph.end(); iter++) {
GLYPH_CHANGED_TYPE c = (*iter)->NewData(this, datatype);
change = (GLYPH_CHANGED_TYPE)((int)change | (int)c);
}
}
return change;
}
/**
* Creates a new CECTag instance for custom data
*
* @param name TAG name
* @param length length of data buffer that will be alloc'ed
* @param dataptr pointer to a void pointer which will be assigned the internal TAG data buffer
*
* \note TAG data buffer has to be filled with valid data after the ctor
*/
CECTag::CECTag(ec_tagname_t name, unsigned int length, void **dataptr) : m_tagName(name)
{
m_dataLen = length;
NewData();
*dataptr = m_tagData;
m_dataType = EC_TAGTYPE_CUSTOM;
}
void DataQueue::AddData(QByteArray* qba)
{
QMutexLocker lock(&m);
OsisData.enqueue(qba);
emit NewData();
}
/**
* Creates a new CECTag instance, which contains a MD4 hash.
*
* This function takes care to store hash in network byte order.
*
* @param name TAG name
* @param data The CMD4Hash class containing the MD4 hash.
*
* @see GetMD4Data()
*/
CECTag::CECTag(ec_tagname_t name, const CMD4Hash& data) : m_tagName(name)
{
m_dataLen = 16;
NewData();
RawPokeUInt64( m_tagData, RawPeekUInt64( data.GetHash() ) );
RawPokeUInt64( m_tagData + 8, RawPeekUInt64( data.GetHash() + 8 ) );
m_dataType = EC_TAGTYPE_HASH16;
}
void CECTag::ConstructStringTag(ec_tagname_t name, const std::string& data)
{
m_tagName = name;
m_dataLen = (ec_taglen_t)strlen(data.c_str()) + 1;
NewData();
memcpy(m_tagData, data.c_str(), m_dataLen);
m_dataType = EC_TAGTYPE_STRING;
}
// Registers a callback function
void WirelessDevice::RegisterWatcher(void *target, WirelessDeviceWatcher function, void *parameter)
{
this->target = target;
this->parameter = parameter;
this->function = function;
if ((function != NULL) && IsDataAvailable())
NewData();
}
/**
* Creates a new CECTag instance, which contains an IPv4 address.
*
* This function takes care of the endianness of the port number.
*
* @param name TAG name
* @param data The EC_IPv4_t class containing the IPv4 address.
*
* @see GetIPv4Data()
*/
CECTag::CECTag(ec_tagname_t name, const EC_IPv4_t& data) : m_tagName(name)
{
m_dataLen = sizeof(EC_IPv4_t);
NewData();
RawPokeUInt32( reinterpret_cast<EC_IPv4_t *>(m_tagData)->m_ip, RawPeekUInt32( data.m_ip ) );
reinterpret_cast<EC_IPv4_t *>(m_tagData)->m_port = ENDIAN_HTONS(data.m_port);
m_dataType = EC_TAGTYPE_IPV4;
}
/** Optimizes the data elements in Data
*/
void TFuncData::Simplify()
{
if(Data.empty())
return;
std::list<TElem> List(Data.begin(), Data.end());
std::list<TElem>::iterator Iter = List.begin();
SimplifyData(List, Iter);
std::vector<TElem> NewData(List.begin(), List.end());
Data.swap(NewData);
}
/**
* Creates a new CECTag instance, which contains a double precision floating point number
*
* @param name TAG name
* @param data double number
*
* @note The actual data is converted to string representation, because we have not found
* yet an effective and safe way to transmit floating point numbers.
*
* @see GetDoubleData()
*/
CECTag::CECTag(ec_tagname_t name, double data) : m_tagName(name)
{
std::ostringstream double_str;
double_str << data;
std::string double_string = double_str.str();
const char * double_chr = double_string.c_str();
m_dataLen = (ec_taglen_t)strlen(double_chr) + 1;
NewData();
memcpy(m_tagData, double_chr, m_dataLen);
m_dataType = EC_TAGTYPE_DOUBLE;
}
// Update Aviable Sessions List
void URadeGameInstance::UpdateSessionList()
{
if (!SessionSearch.IsValid())return;
CurrentSessionSearch.Empty();
for (int32 i = 0; i < SessionSearch->SearchResults.Num(); i++)
{
FAvaiableSessionsData NewData(SessionSearch->SearchResults[i]);
CurrentSessionSearch.Add(NewData);
}
}
/**
* Creates a new CECTag instance from the given data
*
* @param name TAG name
* @param length length of data buffer
* @param data TAG data
*
*/
CECTag::CECTag(ec_tagname_t name, unsigned int length, const void *data) : m_tagName(name)
{
if (data) {
m_dataLen = length;
NewData();
memcpy(m_tagData, data, m_dataLen);
} else {
wxASSERT(length == 0);
m_dataLen = 0;
m_tagData = NULL;
}
m_dataType = EC_TAGTYPE_CUSTOM;
}
void RuleListCtrl::OnGameQuery(PyEvent &evt)
{
PyPrintDebug(false, "Rules list got query\n");
GameData *gdata = evt.GetGdata();
wxASSERT(gdata != NULL);
if (m_rules)
delete m_rules;
m_rules = gdata->rules;
gdata->rules = NULL;
wxASSERT(m_rules != NULL);
NewData(m_rules->GetCount());
}
/************************************************************************************
函数名称：
bool CField::SetAsInteger(int Value)
功能说明：虚函數,将m_pValve所指向的数据修改为传入的int型数据.
详细解释：1.如果子类没有实现,则仅实现错误提示,以示不能转换.
2.如果子类实现,将调用子类的方法.
出入参数：
[in]: 无.
[out]:无.
返回类型：bool
制作：YTLI 2002/07/15
修改:
************************************************************************************/
bool CField::SetAsInteger(int Value)
{
if(m_nNextModifyField == -1)
return false;
else
{
if(m_pFields->IsConvertToLastVersion(this))
{
NewData();
SetAsInteger(Value);
CField* pNewField = m_pFields->m_FieldVersion.GetFieldByAbsolutePos(m_nNextModifyField);
pNewField ->ConvertToCurField(this);
DeleteData();
}
}
return true;
}
/************************************************************************************
函数名称：
bool CField::SetAsDouble(double Value)
功能说明：虚函數,将m_pValve所指向的数据修改为传入的double型数据.
详细解释：1.如果子类没有实现,则仅实现错误提示,以示不能转换.
2.如果子类实现,将调用子类的方法.
出入参数：
[in]: 无.
[out]:无.
返回类型：bool
制作：YTLI 2002/07/15
修改:
************************************************************************************/
bool CField::SetAsDouble(double Value)
{
if(m_nNextModifyField == -1)
return false;
else
{
if(m_pFields->IsConvertToLastVersion(this))
{
NewData();
SetAsDouble(Value);//###_Mod 2002-9-26 zlq
CField* pNewField = m_pFields->m_FieldVersion.GetFieldByAbsolutePos(m_nNextModifyField);
pNewField ->ConvertToCurField(this);
DeleteData();
}
}
return true;
}
void FClassBrowseHelper::BuildClassGraph()
{
UClass* RootNodeClass = UBTNode::StaticClass();
TArray<TSharedPtr<FClassDataNode> > NodeList;
RootNode.Reset();
// gather all native classes
for (TObjectIterator<UClass> It; It; ++It)
{
UClass* TestClass = *It;
if (TestClass->HasAnyClassFlags(CLASS_Native) && TestClass->IsChildOf(RootNodeClass))
{
TSharedPtr<FClassDataNode> NewNode = MakeShareable(new FClassDataNode);
NewNode->ParentClassName = TestClass->GetSuperClass()->GetName();
FClassData NewData(TestClass);
NewNode->Data = NewData;
if (TestClass == RootNodeClass)
{
RootNode = NewNode;
}
NodeList.Add(NewNode);
}
}
// gather all blueprints
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
TArray<FAssetData> BlueprintList;
FARFilter Filter;
Filter.ClassNames.Add(UBlueprint::StaticClass()->GetFName());
AssetRegistryModule.Get().GetAssets(Filter, BlueprintList);
for (int32 i = 0; i < BlueprintList.Num(); i++)
{
TSharedPtr<FClassDataNode> NewNode = CreateClassDataNode(BlueprintList[i]);
NodeList.Add(NewNode);
}
// build class tree
AddClassGraphChildren(RootNode, NodeList);
}
void ASI::RemoveFromLayout(CRef& cref, CRef& layout)
{
Component* pLayoutComponent = layout.GetInstance();
if (pLayoutComponent != NULL)
{
int funcSet = pLayoutComponent->GetFuncSet("{f742f223-bb7b-48f0-92a8-81702e14de16}");
int emitter = pLayoutComponent->GetEmitter("{b11a0db4-cb96-4bf6-9631-fd96f20ea6ab}");
int receiver = pLayoutComponent->GetReceiver("{6a7ab00f-1ab4-4324-9eb4-e614bfca4a16}");
if ((funcSet != -1) &&
(emitter != -1) &&
(receiver != -1))
{
Component* pComponent = cref.GetInstance();
if (pComponent != NULL)
{
if (pComponent->m_pData->inLayout &&
IsParent(pLayoutComponent, pComponent))
{
/*
* Tell the layout component to remove
* the item with the given CRef id.
*/
DRef dref = NewData(BOI_STD_D(Int));
*dref.GetWriteInstance<int>() = cref.Id();
pLayoutComponent->CallFunc(funcSet, 2, dref, true);
DisconnectFromReceiver(pLayoutComponent, emitter, cref);
DisconnectFromReceiver(pComponent, BOI_STD_E(ParentBoundingBox), layout);
pComponent->m_pData->inLayout = false;
CRef invalidCRef;
pComponent->SetParent(invalidCRef);
}
cref.ReleaseInstance();
}
}
layout.ReleaseInstance();
}
}
void ASI::AddToLayout(CRef& cref, CRef& layout)
{
Component* pLayoutComponent = layout.GetInstance();
if (pLayoutComponent != NULL)
{
int funcSet = pLayoutComponent->GetFuncSet("{f742f223-bb7b-48f0-92a8-81702e14de16}");
int emitter = pLayoutComponent->GetEmitter("{b11a0db4-cb96-4bf6-9631-fd96f20ea6ab}");
int receiver = pLayoutComponent->GetReceiver("{6a7ab00f-1ab4-4324-9eb4-e614bfca4a16}");
if ((funcSet != -1) &&
(emitter != -1) &&
(receiver != -1))
{
Component* pComponent = cref.GetInstance();
if (pComponent != NULL)
{
if ((!pComponent->m_pData->inLayout) &&
(pComponent != pLayoutComponent))
{
pComponent->SetParent(layout);
/*
* Tell the layout component to add
* a new item with the given CRef id.
*/
DRef dref = NewData(BOI_STD_D(Int));
*dref.GetWriteInstance<int>() = cref.Id();
pLayoutComponent->CallFunc(funcSet, 1, dref, true);
ConnectToReceiver(pLayoutComponent, emitter, cref, BOI_STD_R(SetPosition));
ConnectToReceiver(pComponent, BOI_STD_E(ParentBoundingBox), layout, receiver);
pComponent->m_pData->inLayout = true;
}
cref.ReleaseInstance();
}
}
layout.ReleaseInstance();
}
}
service::service( ) {
timer1 = new QTimer(this);
timer1->setSingleShot(true);
timer2 = new QTimer(this);
timer2->setSingleShot(true);
timer3 = new QTimer(this);
timer3->setSingleShot(true);
distimer = new QTimer(this);
server = new socket;
connected = false;
QObject::connect( timer1, SIGNAL(timeout()), this, SLOT(JoinRaffle1()) );
QObject::connect( timer2, SIGNAL(timeout()), this, SLOT(JoinRaffle2()) );
QObject::connect( timer3, SIGNAL(timeout()), this, SLOT(JoinRaffle3()) );
QObject::connect( distimer, SIGNAL(timeout()), this, SLOT(reconnect()) );
QObject::connect( server, SIGNAL(NewData(QString)), this, SLOT(ParseString(QString)) );
QObject::connect( server, SIGNAL(Disconnected()), this, SLOT(Disconnection()) );
QObject::connect( server, SIGNAL(Connected()), this, SLOT(Connection()) );
}
/**
* Copy assignment operator.
*
* std::vector uses this, but the compiler-supplied version wouldn't properly
* handle m_dynamic and m_tagData. This wouldn't be necessary if m_tagData
* was a smart pointer (Hi, Kry!).
*/
CECTag& CECTag::operator=(const CECTag& tag)
{
if (&tag != this) {
m_tagName = tag.m_tagName;
m_dataLen = tag.m_dataLen;
m_dataType = tag.m_dataType;
delete [] m_tagData;
if (m_dataLen != 0) {
NewData();
memcpy(m_tagData, tag.m_tagData, m_dataLen);
} else {
m_tagData = NULL;
}
m_tagList.clear();
for (const_iterator it = tag.begin(); it != tag.end(); ++it) {
m_tagList.push_back(*it);
}
}
return *this;
}
int main()
{
__esan::HashTable<int, int> IntTable;
assert(IntTable.size() == 0);
// Test iteration on an empty table.
int Count = 0;
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
// Empty.
}
assert(Count == 0);
bool Added = IntTable.add(4, 42);
assert(Added);
assert(!IntTable.add(4, 42));
assert(IntTable.size() == 1);
int Value;
bool Found = IntTable.lookup(4, Value);
assert(Found && Value == 42);
// Test iterator.
IntTable.lock();
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
assert((*Iter).Key == 4);
assert((*Iter).Data == 42);
}
IntTable.unlock();
assert(Count == 1);
assert(Count == IntTable.size());
assert(!IntTable.remove(5));
assert(IntTable.remove(4));
// Test a more complex payload.
__esan::HashTable<int, MyDataPayload> DataTable(4);
MyDataPayload NewData(new MyData("mystring"));
Added = DataTable.add(4, NewData);
assert(Added);
MyDataPayload FoundData;
Found = DataTable.lookup(4, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "mystring") == 0);
assert(!DataTable.remove(5));
assert(DataTable.remove(4));
// Test resize.
for (int i = 0; i < 4; ++i) {
MyDataPayload MoreData(new MyData("delete-at-end"));
Added = DataTable.add(i+1, MoreData);
assert(Added);
assert(!DataTable.add(i+1, MoreData));
}
for (int i = 0; i < 4; ++i) {
Found = DataTable.lookup(i+1, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.lock();
Count = 0;
for (auto Iter = DataTable.begin(); Iter != DataTable.end();
++Iter, ++Count) {
int Key = (*Iter).Key;
FoundData = (*Iter).Data;
assert(Key >= 1 && Key <= 4);
assert(strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Ensure the iterator supports a range-based for loop.
DataTable.lock();
Count = 0;
for (auto Pair : DataTable) {
assert(Pair.Key >= 1 && Pair.Key <= 4);
assert(strcmp(Pair.Data.Data->Buf, "delete-at-end") == 0);
++Count;
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Test payload freeing via smart pointer wrapper.
__esan::HashTable<MyDataPayload, MyDataPayload, true> DataKeyTable;
MyDataPayload DataA(new MyData("string AB"));
DataKeyTable.lock();
Added = DataKeyTable.add(DataA, DataA);
assert(Added);
Found = DataKeyTable.lookup(DataA, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "string AB") == 0);
MyDataPayload DataB(new MyData("string AB"));
Added = DataKeyTable.add(DataB, DataB);
assert(!Added);
DataKeyTable.remove(DataB); // Should free the DataA payload.
DataKeyTable.unlock();
// Test custom functors.
struct CustomHash {
size_t operator()(int Key) const { return Key % 4; }
};
struct CustomEqual {
bool operator()(int Key1, int Key2) const { return Key1 %4 == Key2 % 4; }
};
__esan::HashTable<int, int, false, CustomHash, CustomEqual> ModTable;
Added = ModTable.add(2, 42);
assert(Added);
Added = ModTable.add(6, 42);
assert(!Added);
fprintf(stderr, "All checks passed.\n");
return 0;
}
//将原来版本的字段数据转换到当前字段的数据。
//1。如果本字段空间为空，生成空间
//2。要进行原来字段空值判断！
//2。1如果为空则本字段为空
//2。2如果不为空则将原来的数据以原来的数据类型读 出，然后调用本字段的SetAs***设置。
//然后，如果有新的next字段，则调用该字段的ConvertToCurField函数，并且负责释放本空间，并且清0
void CField::ConvertToCurField(CField* pOldField)
{
/*
if(this->GetFieldType() == fString)
{
ConvertToCurField(pOldField);
return ;
}
*/
if(!m_pValue)
{//本字段也为中间字段
NewData();
if(pOldField->IsNull())
SetNull();
else
{
CFieldType ftType = pOldField->GetFieldType();
if( ftType == fBoolean )
SetAsBool( pOldField->GetAsBool());
else if( ftType == fCurrency )
SetAsCurrency( pOldField->GetAsCurrency());
else if( ftType == fDate )
//SetAsBool( pOldField->GetAsDateTime());
SetAsBool( true);//#_修改 2002-12-2 $ 10:01:35 zlq
else if( ftType == fDouble )
SetAsDouble( pOldField->GetAsDouble());
else if( ftType == fInt )
SetAsInteger( pOldField->GetAsInteger());
else if( ftType == fString )
SetAsString( pOldField->GetAsString());
//assert(m_nNextModifyField != -1);
CField* pNewField = m_pFields->m_FieldVersion.GetFieldByAbsolutePos(m_nNextModifyField);
pNewField->ConvertToCurField(this);
}
DeleteData();
}
else //最后一层转换.
{
if(pOldField->IsNull())
SetNull();
else
{
if( pOldField->GetFieldType() == fBoolean )
SetAsBool( pOldField->GetAsBool());
else if( pOldField->GetFieldType() == fCurrency )
SetAsCurrency( pOldField->GetAsCurrency());
else if( pOldField->GetFieldType() == fDate )
//SetAsBool( pOldField->GetAsDateTime());
SetAsBool( true);
else if( pOldField->GetFieldType() == fDouble )
SetAsDouble( pOldField->GetAsDouble());
else if( pOldField->GetFieldType() == fInt )
SetAsInteger( pOldField->GetAsInteger());
else if( pOldField->GetFieldType() == fString )
SetAsString( pOldField->GetAsString());
//assert(m_nNextModifyField == -1);
}
}
}
void PutVertex(const contour_pt &j) {
double *p = NewData();
p[0] = j.x, p[1] = j.y, p[2] = 0;
gluTessVertex(tobj, p, p);
}
