bool IOBuffer::ReadFromUDPFd(int32_t fd, int32_t &recvAmount, sockaddr_in &peerAddress) { SANITY_INPUT_BUFFER; if (_published + 65536 > _size) { if (!EnsureSize(65536)) { SANITY_INPUT_BUFFER; return false; } } recvAmount = recvfrom(fd, (char *) (_pBuffer + _published), 65536, MSG_NOSIGNAL, (sockaddr *) & peerAddress, &_dummy); if (recvAmount > 0) { _published += (uint32_t) recvAmount; SANITY_INPUT_BUFFER; return true; } else { #ifdef WIN32 uint32_t err = LASTSOCKETERROR; if (err == SOCKERROR_RECV_CONN_RESET) { WARN("Windows is stupid enough to issue a CONNRESET on a UDP socket. See http://support.microsoft.com/?kbid=263823 for details"); SANITY_INPUT_BUFFER; return true; } #endif FATAL("Unable to read data from UDP socket. Error was: %"PRIu32, LASTSOCKETERROR); SANITY_INPUT_BUFFER; return false; } }
//============================================================ TBool FFileString16::LoadFile(TCharC* pFileName){ // 打开文件 TFileHandle handle; #ifdef _MO_WINDOWS MO_LIB_FILE_OPEN(&handle, pFileName, TC("rb")); #else handle = fopen(pFileName, TC("rb")); #endif if(NULL == handle){ MO_PERROR(fopen); return EFalse; } // 获得长度 if(ESuccess != fseek(handle, 0, SEEK_END)){ MO_PERROR(fseek); return EFalse; } TInt length = ftell(handle); EnsureSize(length); // 从开始位置读取 if(ESuccess != fseek(handle, 0, SEEK_SET)){ MO_PERROR(fseek); return EFalse; } TInt readed = fread(_pMemory, length, 1, handle); if(1 != readed){ MO_PFATAL(fread); } _length = length; // 关闭文件 if(ESuccess != fclose(handle)){ MO_PFATAL(fclose); } return ETrue; }
void CINFManager::Append(CINFManager& Manager, const CVector<int>& DispTable, CIndex * Parent) { cout << " [merging INFs]"; cout.flush(); CProgress Progress(10); bool bIdentical = false; int DispTableMax = 0; for (register int d=0;d<(int)DispTable.GetSize();d++) DispTableMax = (DispTableMax < DispTable[d])?DispTable[d]:DispTableMax; EnsureSize(DispTableMax + 1); for (register int i=0;i<(int) Manager.GetSize();i++) { int DispTableIndex = DispTable[i]; Progress.Show(i, Manager.GetSize()); /* if target is empty */ if (!Manager.GetSize(i)) { /* the other one is not indexed */ } else if (!m_INFVector[DispTableIndex].GetSize()) { /* the other one is indexed, but local is not */ m_INFVector[DispTableIndex] = Manager[i]; } else { /* both sides have indexed the page, keep it as is, should get the most recent*/ if (m_INFVector[DispTableIndex] != Manager[i]) { if (!bIdentical) { cout << "{\n [warning, identical urls are referenced in both indexes]"; bIdentical = true; } cout << "\n {url: " << Parent->GetURLLink(DispTableIndex) << "}"; cout.flush(); } } } Progress.Finish(); cout << "[" << m_INFVector.GetSize() << " INF entries]" << endl; }
bool IOBuffer::ReadFromUDPFd(int32_t fd, int32_t &recvAmount, sockaddr_in &peerAddress) { SANITY_INPUT_BUFFER; if (_published + 65536 > _size) { if (!EnsureSize(65536)) { SANITY_INPUT_BUFFER; return false; } } recvAmount = recvfrom(fd, (char *) (_pBuffer + _published), 65536, MSG_NOSIGNAL, (sockaddr *) & peerAddress, &_dummy); if (recvAmount > 0) { _published += (uint32_t) recvAmount; SANITY_INPUT_BUFFER; return true; } else { int err = LASTSOCKETERROR; #ifdef WIN32 //Patch from https://groups.google.com/forum/#!msg/c-rtmp-server/6W0iHZ8fS_w/b4c5ODm1NfUJ if ((err == WSAECONNRESET) || (err == WSAENETRESET) || (err == WSAEMSGSIZE)) { WARN("Windows is stupid enough to issue a CONNRESET on a UDP socket. See http://support.microsoft.com/?kbid=263823 for details"); SANITY_INPUT_BUFFER; return true; } #endif /* WIN32 */ FATAL("Unable to read data from UDP socket. Error was: %d", err); SANITY_INPUT_BUFFER; return false; } }
void MemoryStream::Write(const uint32_t size, const void* pData) { EnsureSize(size); uint32_t* pointer = reinterpret_cast<uint32_t*>(m_data + m_position); memcpy(pointer, pData, size); m_position += size; }
bool IOBuffer::ReadFromTCPFd(int32_t fd, uint32_t expected, int32_t &recvAmount) { SANITY_INPUT_BUFFER; if (_published + expected > _size) { if (!EnsureSize(expected)) { SANITY_INPUT_BUFFER; return false; } } recvAmount = recv(fd, (char *) (_pBuffer + _published), expected, MSG_NOSIGNAL); if (recvAmount > 0) { _published += (uint32_t) recvAmount; SANITY_INPUT_BUFFER; return true; } else { int err = LASTSOCKETERROR; if ((err != SOCKERROR_EAGAIN)&&(err != SOCKERROR_EINPROGRESS)) { FATAL("Unable to read data. Size advertised by network layer was %"PRIu32". Permanent error: %d", expected, err); SANITY_INPUT_BUFFER; return false; } // else { // WARN("SOCKERROR_EAGAIN or SOCKERROR_EINPROGRESS encountered"); // } return true; } }
bool IOBuffer::ReadFromPipe(int32_t fd, uint32_t expected, int32_t &recvAmount) { //TODO: This is an UGLY hack. #ifndef WIN32 SANITY_INPUT_BUFFER; if (_published + expected > _size) { if (!EnsureSize(expected)) { SANITY_INPUT_BUFFER; return false; } } recvAmount = read(fd, (char *) (_pBuffer + _published), expected); if (recvAmount > 0) { _published += (uint32_t) recvAmount; SANITY_INPUT_BUFFER; return true; } else { int err = errno; if (err != EINPROGRESS) { FATAL("Unable to read from pipe: (%d) %s", err, strerror(err)); SANITY_INPUT_BUFFER; return false; } SANITY_INPUT_BUFFER; return true; } #else NYIA; return false; #endif }
void IOBuffer::ReadFromByte(uint8_t byte) { SANITY_INPUT_BUFFER; EnsureSize(1); _pBuffer[_published] = byte; _published++; SANITY_INPUT_BUFFER; }
//================================================================================================= bool QuestManager::Read(BitStream& stream) { const int QUEST_MIN_SIZE = sizeof(int) + sizeof(byte) * 3; word quest_count; if(!stream.Read(quest_count) || !EnsureSize(stream, QUEST_MIN_SIZE * quest_count)) { Error("Read world: Broken packet for quests."); return false; } quests.resize(quest_count); int index = 0; for(Quest*& quest : quests) { quest = new PlaceholderQuest; quest->quest_index = index; if(!stream.Read(quest->refid) || !stream.ReadCasted<byte>(quest->state) || !ReadString1(stream, quest->name) || !ReadStringArray<byte, word>(stream, quest->msgs)) { Error("Read world: Broken packet for quest %d.", index); return false; } ++index; } return true; }
void IOBuffer::ReadFromRepeat(uint8_t byte, uint32_t size) { SANITY_INPUT_BUFFER; EnsureSize(size); memset(_pBuffer + _published, byte, size); _published += size; SANITY_INPUT_BUFFER; }
void IOBuffer::Initialize(uint32_t expected) { if ((_pBuffer != NULL) || (_size != 0) || (_published != 0) || (_consumed != 0)) ASSERT("This buffer was used before. Please initialize it before using"); EnsureSize(expected); }
/** * @param pszStrData - data source. * @param nLength - string length. */ void CStrStream::AppendData(PCTSTR pszStrData, size_t nLength) { if (pszStrData && *pszStrData) { size_t nNewLength = m_nLength + nLength; EnsureSize(nNewLength + 1, true); _tcsncpy_s(m_pszData + m_nLength, nLength + 1, pszStrData, nLength); m_nLength = nNewLength; } }
/** * @param pszSubstring - inserted string buffer. * @param nPosition - start position. * @param nLength - length of the inserted string. */ void CStrStream::Insert(PCTSTR pszSubstring, size_t nPosition, size_t nLength) { ValidateIndex(nPosition); size_t nNewLength = m_nLength + nLength; EnsureSize(nNewLength + 1, true); size_t nNextPosition = nPosition + nLength; size_t nNextLength = m_nLength - nPosition; MoveMemory(m_pszData + nNextPosition, m_pszData + nPosition, (nNextLength + 1) * sizeof(TCHAR)); MoveMemory(m_pszData + nPosition, pszSubstring, nLength * sizeof(TCHAR)); m_nLength = nNewLength; }
void MemoryStream::Write(const std::string& value) { const uint32_t additionalSize = static_cast<uint32_t>(sizeof(uint32_t) + value.length()); EnsureSize(additionalSize); uint32_t* pointer = reinterpret_cast<uint32_t*>(m_data + m_position); *pointer = static_cast<uint32_t>(value.length()); ++pointer; memcpy(pointer, value.data(), value.length()); m_position += additionalSize; }
bool IOBuffer::ReadFromBuffer(const uint8_t *pBuffer, const uint32_t size) { SANITY_INPUT_BUFFER; if (!EnsureSize(size)) { SANITY_INPUT_BUFFER; return false; } memcpy(_pBuffer + _published, pBuffer, size); _published += size; SANITY_INPUT_BUFFER; return true; }
/** * @param pszStrData - data source. */ void CStrStream::AppendData(PCSTR pszStrData) { if (pszStrData && *pszStrData) { int nSize = MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, NULL, 0); _ASSERTE(nSize > 0); size_t nNewSize = m_nLength + nSize; EnsureSize(nNewSize, true); MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, m_pszData + m_nLength, nSize); m_nLength = nNewSize - 1; } }
/** * @param pszStrData - data source. */ void CStrStream::AppendData(PCWSTR pszStrData) { if (pszStrData && *pszStrData) { size_t nSize = WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, NULL, 0, NULL, NULL); _ASSERTE(nSize > 0); size_t nNewSize = m_nLength + nSize; EnsureSize(nNewSize, true); WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, m_pszData + m_nLength, (int)nSize, NULL, NULL); m_nLength = nNewSize - 1; } }
/** * @param pszStrData - data source. */ void CStrStream::CopyData(PCSTR pszStrData) { if (pszStrData && *pszStrData) { int nSize = MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, NULL, 0); _ASSERTE(nSize > 0); EnsureSize(nSize, false); MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, m_pszData, nSize); m_nLength = nSize - 1; } else Reset(); }
/** * @param pszStrData - data source. */ void CStrStream::CopyData(PCWSTR pszStrData) { if (pszStrData && *pszStrData) { size_t nSize = WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, NULL, 0, NULL, NULL); _ASSERTE(nSize > 0); EnsureSize(nSize, false); WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, m_pszData, (int)nSize, NULL, NULL); m_nLength = nSize - 1; } else Reset(); }
void ArrayBase::__SetSize(int inSize) { if (inSize<length) { int s = GetElementSize(); memset(mBase + inSize*s, 0, (length-inSize)*s); length = inSize; } else if (inSize>length) { EnsureSize(inSize); length = inSize; } }
void CompositorD3D11::EndFrame() { nsIntSize oldSize = mSize; EnsureSize(); UINT presentInterval = 0; if (gfxWindowsPlatform::GetPlatform()->IsWARP()) { // When we're using WARP we cannot present immediately as it causes us // to tear when rendering. When not using WARP it appears the DWM takes // care of tearing for us. presentInterval = 1; } if (oldSize == mSize) { RefPtr<IDXGISwapChain1> chain; HRESULT hr = mSwapChain->QueryInterface((IDXGISwapChain1**)byRef(chain)); if (SUCCEEDED(hr) && chain) { DXGI_PRESENT_PARAMETERS params; PodZero(¶ms); params.DirtyRectsCount = mInvalidRegion.GetNumRects(); std::vector<RECT> rects; rects.reserve(params.DirtyRectsCount); nsIntRegionRectIterator iter(mInvalidRegion); const nsIntRect* r; uint32_t i = 0; while ((r = iter.Next()) != nullptr) { RECT rect; rect.left = r->x; rect.top = r->y; rect.bottom = r->YMost(); rect.right = r->XMost(); rects.push_back(rect); } params.pDirtyRects = &rects.front(); chain->Present1(presentInterval, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0, ¶ms); } else { mSwapChain->Present(presentInterval, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0); } mDisableSequenceForNextFrame = false; if (mTarget) { PaintToTarget(); } } mCurrentRT = nullptr; }
/** * @param pszStrData - data source. * @param nLength - string length. */ void CStrStream::CopyData(PCTSTR pszStrData, size_t nLength) { if (m_pszData != pszStrData) { if (pszStrData && *pszStrData) { size_t nSize = nLength + 1; EnsureSize(nSize, false); _tcsncpy_s(m_pszData, nSize, pszStrData, nLength); m_nLength = nLength; } else Reset(); } }
void CompositorD3D9::EndFrame() { device()->EndScene(); nsIntSize oldSize = mSize; EnsureSize(); if (oldSize == mSize) { if (mTarget) { PaintToTarget(); } else { mSwapChain->Present(); } } mCurrentRT = nullptr; }
/** * liest vom Socket die Paketdatenmenge * * @author FloSoft */ int Message::recv(Socket& sock, unsigned int length) { if(!length) return 0; EnsureSize(length); int read = sock.Recv(GetDataWritable(), length); SetLength(length); if(length != (unsigned int)read ) { LOG.lprintf("recv: data: only got %d bytes instead of %d\n", read, length); return -1; } return 0; }
int Vector::Add(Object* element,int b_allowDuplicates) { if(!b_allowDuplicates){ if(Get(element)!=-1) return size; } element->ref(); //increment this objects reference count if(tlength<size+1) EnsureSize((size+1)<<1); //double the size of the array. this will make allocations rare to help reduce memory fragmentation, copying, etc. vector[size]=element; size++; return size;//return the new size of the vector }
void CompositorD3D11::EndFrame() { mContext->Flush(); nsIntSize oldSize = mSize; EnsureSize(); if (oldSize == mSize) { mSwapChain->Present(0, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0); mDisableSequenceForNextFrame = false; if (mTarget) { PaintToTarget(); } } mCurrentRT = nullptr; }
void CompositorD3D11::EndFrame() { mContext->Flush(); nsIntSize oldSize = mSize; EnsureSize(); if (oldSize == mSize) { mSwapChain->Present(0, 0); if (mTarget) { PaintToTarget(); } } mCurrentRT = nullptr; }
void CompositorD3D9::BeginFrame(const nsIntRegion& aInvalidRegion, const Rect *aClipRectIn, const gfxMatrix& aTransform, const Rect& aRenderBounds, Rect *aClipRectOut, Rect *aRenderBoundsOut) { if (!mSwapChain->PrepareForRendering()) { return; } mDeviceManager->SetupRenderState(); EnsureSize(); device()->Clear(0, NULL, D3DCLEAR_TARGET, 0x00000000, 0, 0); device()->BeginScene(); if (aClipRectOut) { *aClipRectOut = Rect(0, 0, mSize.width, mSize.height); } if (aRenderBoundsOut) { *aRenderBoundsOut = Rect(0, 0, mSize.width, mSize.height); } RECT r; if (aClipRectIn) { r.left = (LONG)aClipRectIn->x; r.top = (LONG)aClipRectIn->y; r.right = (LONG)(aClipRectIn->x + aClipRectIn->width); r.bottom = (LONG)(aClipRectIn->y + aClipRectIn->height); } else { r.left = r.top = 0; r.right = mSize.width; r.bottom = mSize.height; } device()->SetScissorRect(&r); nsRefPtr<IDirect3DSurface9> backBuffer = mSwapChain->GetBackBuffer(); mDefaultRT = new CompositingRenderTargetD3D9(backBuffer, INIT_MODE_CLEAR, IntRect(0, 0, mSize.width, mSize.height)); SetRenderTarget(mDefaultRT); }
bool IOBuffer::ReadFromStdio(int32_t fd, uint32_t expected, int32_t &recvAmount) { SANITY_INPUT_BUFFER; if (_published + expected > _size) { if (!EnsureSize(expected)) { SANITY_INPUT_BUFFER; return false; } } recvAmount = READ_FD(fd, (char *) (_pBuffer + _published), expected); if (recvAmount > 0) { _published += (uint32_t) recvAmount; SANITY_INPUT_BUFFER; return true; } else { SANITY_INPUT_BUFFER; return false; } }
bool IOBuffer::ReadFromFs(MmapFile &file, uint32_t size) { SANITY_INPUT_BUFFER; if (size == 0) { SANITY_INPUT_BUFFER; return true; } if (_published + size > _size) { if (!EnsureSize(size)) { SANITY_INPUT_BUFFER; return false; } } if (!file.ReadBuffer(_pBuffer + _published, size)) { SANITY_INPUT_BUFFER; return false; } _published += size; SANITY_INPUT_BUFFER; return true; }