Bool GetFileSizeTest() { Bool result = true; File* file; //File does not exists, GetFileSize returns 0 File::Delete(_fileName); CHECK File::GetFileSize(_fileName) == 0; //File exists, but is empty, GetFileSize returns 0 file = File::Create(_fileName); CHECK file->GetFileSize() == 0; DeletePtr(file) CHECK File::GetFileSize(_fileName) == 0; //File exists, and is not empty, GetFileSize returns size file = File::Open(_fileName); file->Write((VoidPtr)_fileName, 5); CHECK file->GetFileSize() == 5; DeletePtr(file) CHECK File::GetFileSize(_fileName) == 5; File::Delete(_fileName); return result; }
Bool OpenReadOnlyTest() { Bool result = true; File* file; String text; UInt fileSize; //File does not exists, open it and it will fail File::Delete(_fileName); file = File::OpenReadOnly(_fileName); CHECK file == 0; //File exists, open it and it will work, write to it and it will fail CHECK (file = File::Create(_fileName)); file->Write((VoidPtr)_fileName, String::CStrByteSize(_fileName)); DeletePtr(file); CHECK (file = File::OpenReadOnly(_fileName)); fileSize = ToUInt(file->GetFileSize()); text.Reserve(fileSize / sizeof(TChar)); file->Read(text.DrivePointer(fileSize / sizeof(TChar)), fileSize); CHECK text == _fileName; DeletePtr(file); File::Delete(_fileName); return result; }
CNcdNodeLink::~CNcdNodeLink() { DLTRACEIN(("")); // Do not delete node here because this link does not own it. delete iParentIdentifier; iParentIdentifier = NULL; delete iRequestParentIdentifier; iRequestParentIdentifier = NULL; delete iMetaDataIdentifier; iMetaDataIdentifier = NULL; delete iTimeStamp; iTimeStamp = NULL; delete iCatalogsSourceName; iCatalogsSourceName = NULL; delete iServerUri; iServerUri = NULL; delete iRemoteUri; iRemoteUri = NULL; DeletePtr( iMetadataTimeStamp ); iQueries.Close(); DLTRACEOUT(("")); }
void CSPtrArray::InsertAt(int nIndex, void * newElement, int nCount /*=1*/) { ASSERT(nIndex >= 0); // will expand to meet need ASSERT(nCount > 0); // zero or negative size not allowed if (nIndex >= m_nSize) { // adding after the end of the array SetSize(nIndex + nCount, -1); // grow so nIndex is valid } else { // inserting in the middle of the array int nOldSize = m_nSize; SetSize(m_nSize + nCount, -1); // grow it to new size // destroy intial data before copying over it DeletePtr(&m_pData[nOldSize], nCount); // shift old data up to fill gap memmove(&m_pData[nIndex+nCount], &m_pData[nIndex], (nOldSize-nIndex) * sizeof(void *)); // re-init slots we copied from //memset(&m_pData[nIndex],0, nCount); } // insert new value in the gap ASSERT(nIndex + nCount <= m_nSize); while (nCount--) m_pData[nIndex++] = newElement; }
CradleGame::~CradleGame() { if (m_Actor) delete[] m_Actor; m_Actor = nullptr; if (m_cd3d) delete m_cd3d; m_cd3d = nullptr; if (m_timer) delete m_timer; m_timer = nullptr; if (m_cInput) delete m_cInput; m_cInput = nullptr; if (m_texture) delete m_texture; m_texture = nullptr; // ReleaseCOM(m_vertexBuffer); // ReleaseCOM(m_vs); // ReleaseCOM(m_ps); DeletePtr(m_camera); if (m_Resources) delete m_Resources; m_Resources = nullptr; if (m_instanceData) delete[] m_instanceData; m_instanceData = nullptr; ReleaseCOM(m_vertexBuffer); }
// --------------------------------------------------------------------------- // Starts the operation asynchronously // --------------------------------------------------------------------------- // void CCatalogsHttpTransaction::AsyncStartL() { DLTRACEIN(("")); DeletePtr( iCallBack ); iCallBack = new ( ELeave ) CAsyncCallBack( iStartCallBack, CActive::EPriorityStandard ); iCallBack->CallBack(); }
Worker::~Worker() { _alive = false; _semaphore.notify(); _thread->join(); DeletePtr(_thread); }
//##ModelId=4049F738001C CSPtrArray::~CSPtrArray() { // TODO: Add your specialized code here. if (m_pData != NULL) { DeletePtr(m_pData, m_nSize); delete[] (BYTE*)m_pData; } }
Bool OpenTest() { Bool result = true; File* file; //File does not exists, open it and it will fail File::Delete(_fileName); file = File::Open(_fileName); CHECK file == 0; //File exists, open it and it will work CHECK (file = File::Create(_fileName)); DeletePtr(file); CHECK (file = File::Open(_fileName)); DeletePtr(file); File::Delete(_fileName); return result; }
Bool SeekToEndTest() { Bool result = true; File* file; //Create, write 6 bytes and close file = File::Create(_fileName); file->Write((VoidPtr)_fileName, 6); DeletePtr(file); //Create, GetSeekPos returns 0, SeekToEnd, GetSeekPos returns 6 file = File::Open(_fileName); CHECK file->GetSeekPos() == 0; file->SeekToEnd(); CHECK file->GetSeekPos() == 6; DeletePtr(file) File::Delete(_fileName); return result; }
Bool CreateTest() { Bool result = true; File* file; //File does not exists, create it and size will be 0 and SeekPos will be 0 File::Delete(_fileName); CHECK (file = File::Create(_fileName)); CHECK file->GetFileSize() == 0; CHECK file->GetSeekPos() == 0; DeletePtr(file); //File exists, create it and it will be truncated and SeekPos will be 0 CHECK (file = File::Create(_fileName)); CHECK file->GetFileSize() == 0; CHECK file->GetSeekPos() == 0; DeletePtr(file); File::Delete(_fileName); return result; }
//##ModelId=404C95C1002C void CSPtrArray::RemoveAt(int nIndex,int nCount) { // TODO: Add your specialized code here. ASSERT(nIndex >= 0); ASSERT(nCount >= 0); ASSERT(nIndex + nCount <= m_nSize); // just remove a range int nMoveCount = m_nSize - (nIndex + nCount); DeletePtr(&m_pData[nIndex], nCount); if (nMoveCount) memmove(&m_pData[nIndex], &m_pData[nIndex + nCount], nMoveCount * sizeof(void *)); m_nSize -= nCount; }
Bool DeleteTest() { Bool result = true; File* file; //File does not exists, Delete returns false CHECK File::Delete(_fileName) == false; //File exists, Delete returns true, then file no longer exists file = File::Create(_fileName); DeletePtr(file) CHECK File::Delete(_fileName) == true; CHECK File::Exists(_fileName) == false; return result; }
Bool ExistsTest() { Bool result = true; File* file; //File does not exists, Exists returns false File::Delete(_fileName); CHECK File::Exists(_fileName) == false; //File exists, Exists returns true file = File::Create(_fileName); DeletePtr(file) CHECK File::Exists(_fileName) == true; File::Delete(_fileName); return result; }
ThreadImpl* ThreadImpl::CreateInstance(ThreadFonc threadEntry, VoidPtr threadParam) { HANDLE threadHandle; ThreadImpl* Thread = new ThreadImpl(threadEntry, threadParam); threadHandle = ::CreateThread(NULL, 0, NativeThreadEntry, (LPVOID)Thread, 0, NULL); if(threadHandle) { Thread->_threadHandle = threadHandle; return Thread; } else { DeletePtr(Thread); return NULL; } }
Bool SeekTest() { Bool result = true; File* file; //Seek is at 0, GetSeekPos returns 0 file = File::Create(_fileName); CHECK file->GetSeekPos() == 0; //Seek is at 3, GetSeekPos returns 3 file->Write((VoidPtr)_fileName, 3); CHECK file->GetSeekPos() == 3; DeletePtr(file) File::Delete(_fileName); return result; }
Bool GetSeekPosTest() { Bool result = true; File* file; //SeekPos is at zero, GetSeekPos returns 0 file = File::Create(_fileName); CHECK file->GetSeekPos() == 0; //SeekPos is at 5, GetSeekPos returns 5 file->Write((VoidPtr)_fileName, 5); CHECK file->GetSeekPos() == 5; DeletePtr(file) File::Delete(_fileName); return result; }
Bool ReadWriteTest() { Bool result = true; File* file; UInt32 const bufferSize = 1024; TChar buffer[bufferSize]; file = File::Create(_fileName); file->Write((VoidPtr)_fileName, String::CStrByteSize(_fileName) + sizeof(TChar)); file->Seek(0); file->Read(buffer, bufferSize); DeletePtr(file); File::Delete(_fileName); String read = buffer; CHECK String::Compare(_fileName, read) == 0; return result; }
// --------------------------------------------------------------------------- // Cancel transaction // --------------------------------------------------------------------------- // TInt CCatalogsHttpTransaction::Cancel() { DLTRACEIN(( "" )); iState.iOperationState = ECatalogsHttpOpDeleting; SetTransferring( EFalse ); if ( iHttp ) { iHttp->CancelTransaction(); DeletePtr( iHttp ); } if ( iState.iProgressState != ECatalogsHttpNone && iState.iProgressState != ECatalogsHttpDone ) { iOwner.CompleteOperation( this ); } DLTRACE(("Calling release")); return Release(); }
ThreadImpl* ThreadImpl::CreateInstance(ThreadFonc threadEntry, VoidPtr threadParam) { Int32 errCode; pthread_t threadID; ThreadImpl* thread = new ThreadImpl(threadEntry, threadParam); errCode = pthread_create(&threadID, NULL, NativeThreadEntry, (void*)thread); if(!errCode) { thread->_threadID = threadID; return thread; } else { SetErrCode((UInt32)errCode); DeletePtr(thread); return NULL; } }
String TextFile::ReadAll(CStr fileName) { Assert(fileName); File* file; String text; UInt fileSize; UInt length; TChar* buffer; file = File::OpenReadOnly(fileName); if(file) { fileSize = ToUInt(file->GetFileSize()); length = fileSize / sizeof(TChar); text.Reserve(length); buffer = text.DrivePointer(length); file->Read(buffer, fileSize); DeletePtr(file); } return text; }
void TextFile::AppendAll(CStr fileName, CStr text, UInt textLength) { TextFile *textFile = TextFile::Append(fileName); textFile->Write(text, textLength); DeletePtr(textFile); }
void TextFile::WriteLine(CStr text) const { Assert(_file); Write(text); Write(NewLine); } void TextFile::WriteLine(String const & text) const { Assert(_file); WriteLine(text, text.Length()); } void TextFile::WriteLine() const { Assert(_file); Write(NewLine); } void TextFile::Close() { DeletePtr(_file) } TextFile::~TextFile() { Close(); } } }
// --------------------------------------------------------------------------- // Encodes the URI // --------------------------------------------------------------------------- // void CCatalogsHttpTransaction::EncodeUriL() { DeletePtr( iEncodedUri ); iEncodedUri = CatalogsHttpUtils::EncodeUriL( Uri() ); }
// --------------------------------------------------------------------------- // Actually starts the transaction // --------------------------------------------------------------------------- // void CCatalogsHttpTransaction::DoStartL() { DLTRACEIN(("")); DASSERT( iConnection ); if ( !iOwner.ConnectionManager().AskConnectionConfirmation( Config().ConnectionMethod() ) ) { DLINFO(("Connection denied!")); User::Leave( KCatalogsErrorHttpConnectionDenied ); } // If the operation disconnected prematurely it will be restarted // so we need to delete the old iHttp DeletePtr( iHttp ); iHttp = CCatalogsHttpStack::NewL( this, *iConnection, iOwner.ConnectionCreatorL() ); iHttp->SetConnectionManager( &iOwner.ConnectionManager() ); UpdateRequestHeadersL(); const TDesC8* method = &KCatalogsHttpPost; // Choose the correct method string switch( Config().HttpMethod() ) { case ECatalogsHttpGet: { method = &KCatalogsHttpGet; break; } case ECatalogsHttpHead: { method = &KCatalogsHttpHead; } default: { } } iState.iOperationState = ECatalogsHttpOpInProgress; iState.iProgressState = ECatalogsHttpStarted; if ( iRequestBody ) { // Send the request iHttp->IssueHttpRequestL( *method, EncodedUri(), ContentType(), *iRequestBody ); } else { // Send the request with empty body iHttp->IssueHttpRequestL( *method, EncodedUri(), ContentType(), KNullDesC8 ); } // Notify observer about operation start // This method can leave so not using NotifyObserver iObserver->HandleHttpEventL( *this, iState ); DLTRACEOUT(("successful")); }
//##ModelId=4049F7440286 void CSPtrArray::SetSize(int nNewSize, int nGrowBy) { // TODO: Add your specialized code here. ASSERT(nNewSize >= 0); if (nGrowBy != -1) m_nGrowBy = nGrowBy; // set new size if (nNewSize == 0) { // shrink to nothing if (m_pData != NULL) { DeletePtr(m_pData, m_nSize); delete[] (BYTE*)m_pData; m_pData = NULL; } m_nSize = m_nMaxSize = 0; } else if (m_pData == NULL) { // create one with exact size #ifdef SIZE_T_MAX // ASSERT(nNewSize <= SIZE_T_MAX/sizeof(void)); // no overflow #endif m_pData = (void**) new BYTE[nNewSize * sizeof(void *)]; memset(m_pData,0,nNewSize * sizeof(void *)); m_nSize = m_nMaxSize = nNewSize; } else if (nNewSize <= m_nMaxSize) { // it fits if (nNewSize > m_nSize) { // initialize the new elements memset(&m_pData[m_nSize],0, (nNewSize-m_nSize)*sizeof(void*)); } else if (m_nSize > nNewSize) { // destroy the old elements DeletePtr(&m_pData[nNewSize],m_nSize-nNewSize); memset(&m_pData[nNewSize],0, (m_nSize-nNewSize)*sizeof(void*)); } m_nSize = nNewSize; } else { // otherwise, grow array int nGrowBy = m_nGrowBy; if (nGrowBy == 0) { // heuristically determine growth when nGrowBy == 0 // (this avoids heap fragmentation in many situations) nGrowBy = m_nSize / 8; nGrowBy = (nGrowBy < 4) ? 4 : ((nGrowBy > 1024) ? 1024 : nGrowBy); } int nNewMax; if (nNewSize < m_nMaxSize + nGrowBy) nNewMax = m_nMaxSize + nGrowBy; // granularity else nNewMax = nNewSize; // no slush ASSERT(nNewMax >= m_nMaxSize); // no wrap around #ifdef SIZE_T_MAX // ASSERT(nNewMax <= SIZE_T_MAX/sizeof(TYPE)); // no overflow #endif void** pNewData = (void **) new BYTE[nNewMax * sizeof(void*)]; // copy new data from old memcpy(pNewData, m_pData, m_nSize * sizeof(void *)); // construct remaining elements ASSERT(nNewSize > m_nSize); memset(&pNewData[m_nSize], 0,(nNewSize-m_nSize)*sizeof(void*)); // get rid of old stuff (note: no destructors called) delete[] m_pData; m_pData = pNewData; m_nSize = nNewSize; m_nMaxSize = nNewMax; } }