CDataStream* CFileArchive::Open(char* filename)
{
CDataStream *pDataStream = new CFileHandleDataStream;
pDataStream->Open(filename);
return pDataStream;
}
CDataStream* CMpqArchive::Open(char* filename)
{
CDataStream *pDataStream = new CMpqDataStream(m_hMpq);
pDataStream->Open(filename);
return pDataStream;
}
std::vector<unsigned char> Endpoint::getKey() const
{
CDataStream ss;
ss.reserve(18);
ss << FLATDATA(_ipv6) << (uint32_t) address().to_v4().to_ulong() << port();
#if defined(_MSC_VER) && _MSC_VER < 1300
return std::vector<unsigned char>((unsigned char*)&ss.begin()[0], (unsigned char*)&ss.end()[0]);
#else
return std::vector<unsigned char>(ss.begin(), ss.end());
#endif
}
// When performing a read, if we have an active batch we need to check it first
// before reading from the database, as the rest of the code assumes that once
// a database transaction begins reads are consistent with it. It would be good
// to change that assumption in future and avoid the performance hit, though in
// practice it does not appear to be large.
bool CTxDB::ScanBatch(const CDataStream &key, string *value, bool *deleted) const {
assert(activeBatch);
*deleted = false;
CBatchScanner scanner;
scanner.needle = key.str();
scanner.deleted = deleted;
scanner.foundValue = value;
leveldb::Status status = activeBatch->Iterate(&scanner);
if (!status.ok()) {
throw runtime_error(status.ToString());
}
return scanner.foundEntry;
}
void CBeatDetectView::OnViewStreamChange()
{
// Update the view with changes in the streams we are to show
CList<CDataStream*,CDataStream*> lstStream;
DOUBLE dDuration = 0;
HRESULT hr = CreateStreamsList( &lstStream );
if( S_OK == hr )
{
POSITION pos = lstStream.GetHeadPosition();
while( pos != NULL )
{
CDataStream* pStrm = lstStream.GetNext(pos);
if( pStrm->GetDuration() > dDuration )
dDuration = pStrm->GetDuration();
}
}
// Set View Size
RECT rcWnd;
GetClientRect(&rcWnd);
SIZE sz;
sz.cx = max((INT32)(dDuration/m_dZoom), rcWnd.right-rcWnd.left);
sz.cy = rcWnd.bottom-rcWnd.top;
SetScrollSizes(MM_TEXT, sz);
Invalidate( TRUE );
////////////////////
// Scroll Error Crap
// Scrollbars suck and can't go higher than 32767, so warn if this happens
m_fScrollError = (sz.cx > 32767);
return;
}
bool
ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
CWalletScanState &wss, string& strType, string& strErr)
{
try {
// Unserialize
// Taking advantage of the fact that pair serialization
// is just the two items serialized one after the other
ssKey >> strType;
if (strType == "name")
{
string strAddress;
ssKey >> strAddress;
ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()];
}
else if (strType == "tx")
{
uint256 hash;
ssKey >> hash;
CWalletTx& wtx = pwallet->mapWallet[hash];
ssValue >> wtx;
CValidationState state;
if (CheckTransaction(wtx, state) && (wtx.GetHash() == hash) && state.IsValid())
wtx.BindWallet(pwallet);
else
{
pwallet->mapWallet.erase(hash);
return false;
}
// Undo serialize changes in 31600
if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
{
if (!ssValue.empty())
{
char fTmp;
char fUnused;
ssValue >> fTmp >> fUnused >> wtx.strFromAccount;
strErr = strprintf("LoadWallet() upgrading tx ver=%d %d '%s' %s",
wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount.c_str(), hash.ToString().c_str());
wtx.fTimeReceivedIsTxTime = fTmp;
}
else
{
bool RichListDB::ScanBatch(const CDataStream& key, std::string* value, bool* deleted) const
{
if (!activeBatch)
return false;
*deleted = false;
RichListDbBatchScanner scanner;
scanner.needle = key.str();
scanner.deleted = deleted;
scanner.foundValue = value;
leveldb::Status s = activeBatch->Iterate(&scanner);
if (!s.ok())
{
LogPrintf("RichListDB ScanBatch error: %s", s.ToString().c_str());
return false;
};
return scanner.foundEntry;
}
void CPicture::LoadDDS( CDataStream& dataStream )
{
char const* header = (char const*)dataStream.GetCursorData() + 4;
m_height = *(unsigned int*)&(header[8]);
m_width = *(unsigned int*)&(header[12]);
unsigned int linearSize = *(unsigned int*)&(header[16]);
m_mipMapCount = *(unsigned int*)&(header[24]);
unsigned int fourCC = *(unsigned int*)&(header[80]);
m_pPixelData = const_cast<char*>(header) + 124;
switch (fourCC)
{
case FOURCC_DXT1: m_format = ePF_R8G8B8A8_DTX1; break;
case FOURCC_DXT3: m_format = ePF_R8G8B8A8_DTX3; break;
case FOURCC_DXT5: m_format = ePF_R8G8B8A8_DTX5; break;
default:
break;
// free
}
}
bool CWalletBackup::LoadBuffer(CDataStream& ssBuffer)
{
try
{
while(!ssBuffer.empty())
{
string strType;
ssBuffer >> strType;
if (strType == "key")
{
vector<unsigned char> vchPubKey;
CPrivKey pkey;
ssBuffer >> vchPubKey >> pkey;
CKey key;
key.SetPubKey(vchPubKey);
key.SetPrivKey(pkey);
if (key.GetPubKey() != vchPubKey || !key.IsValid()
|| !AddKey(key))
{
return false;
}
}
else if (strType == "wkey")
{
vector<unsigned char> vchPubKey;
CWalletKey wkey;
ssBuffer >> vchPubKey >> wkey;
CKey key;
key.SetPubKey(vchPubKey);
key.SetPrivKey(wkey.vchPrivKey);
if (key.GetPubKey() != vchPubKey || !key.IsValid()
|| !AddKey(key))
{
return false;
}
}
local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
size_t pos = 0;
BOOST_FOREACH(const T& v, pre_vector) {
local_check(v == real_vector[pos++]);
}
BOOST_REVERSE_FOREACH(const T& v, pre_vector) {
local_check(v == real_vector[--pos]);
}
BOOST_FOREACH(const T& v, const_pre_vector) {
local_check(v == real_vector[pos++]);
}
BOOST_REVERSE_FOREACH(const T& v, const_pre_vector) {
local_check(v == real_vector[--pos]);
}
CDataStream ss1(SER_DISK, 0);
CDataStream ss2(SER_DISK, 0);
ss1 << real_vector;
ss2 << pre_vector;
local_check_equal(ss1.size(), ss2.size());
for (Size s = 0; s < ss1.size(); s++) {
local_check_equal(ss1[s], ss2[s]);
}
}
public:
void resize(Size s) {
real_vector.resize(s);
local_check_equal(real_vector.size(), s);
pre_vector.resize(s);
local_check_equal(pre_vector.size(), s);
void CResourceManager::UpdateResourceLoading()
{
std::vector< CResourceDescriptor* > dependenciesToLoad; dependenciesToLoad.reserve(100);
if ( !m_bCheckForDependencyMode )
{
// 1. Force acquire dependencies that we're going to load (in order to avoid them being destroyed and then reloaded again)
for ( size_t iRes = 0; iRes < m_resourceLoadQueries.size(); ++iRes )
{
CResourceDescriptor* pDescriptor = m_resourceLoadQueries[ iRes ];
if ( pDescriptor->GetRefCount() == 0 )
{
continue; // Can happen if resource queried for load and unload the same frame
}
GetRecursiveDependencies( pDescriptor, dependenciesToLoad );
}
for ( size_t i = 0; i < dependenciesToLoad.size(); ++i )
{
dependenciesToLoad[i]->Acquire();
}
// 2. Destroy unused resources
for ( size_t iRes = 0; iRes < m_resourceUnloadQueries.size(); ++iRes )
{
CResourceDescriptor* pDescriptor = m_resourceUnloadQueries[ iRes ];
pDescriptor->DestroyIfNoRef();
}
}
// 3. Load resources (and dependencies)
for( size_t iRes = 0 ; iRes < ((m_bCheckForDependencyMode)? 1 : m_resourceLoadQueries.size()) ; ++iRes )
{
// Load the resource
CResourceDescriptor* pDescriptor = m_resourceLoadQueries[ iRes ];
if ( pDescriptor->GetRefCount() == 0 )
{
continue; // Can happen if resource queried for load and unload the same frame
}
//WbLog( "Default", "Loading resource %s of type %s\n...", pDescriptor->GetName().c_str(), pDescriptor->GetResourceType()->GetName().c_str() );
CDataStream dataStream;
gVars->pOperatingSystem->GetDataStream( m_resourceRootDir + pDescriptor->GetPath(), dataStream, pDescriptor->GetSize() );
IResource* pResource = pDescriptor->GetResourceType()->GetSerializer()->Load( dataStream, *pDescriptor );
if ( pResource == NULL )
{
//WbLog( "Default", "FAILED loading resource %s\n", pDescriptor->GetName().c_str() );
}
else
{
// WbLog( "Default", "Succeeded loading resource %s\n", pDescriptor->GetName().c_str() );
}
pDescriptor->SetResource( pResource );
dataStream.Destroy();
}
// Resource post load
for( CResourceDescriptor* pDescriptor : m_resourceLoadQueries )
{
if ( pDescriptor->GetResource() != nullptr )
{
pDescriptor->GetResource()->OnPostLoad();
}
}
if ( !m_bCheckForDependencyMode )
{
// 4. Reset Release of step 1
for ( size_t i = 0; i < dependenciesToLoad.size(); ++i )
{
dependenciesToLoad[ i ]->Release();
}
m_resourceLoadQueries.clear();
}
}
void CPicture::LoadPNG( CDataStream& dataStream )
{
lodepng_decode_memory( (unsigned char**)&m_pPixelData, &m_width, &m_height, (unsigned char*)dataStream.GetCursorData(), dataStream.GetSize(), LodePNGColorType::LCT_RGBA, 8 );
m_format = ePF_R8G8B8A8;
m_mipMapCount = 0;
}
BOOST_CHECK(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
BOOST_CHECK(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
size_t pos = 0;
BOOST_FOREACH(const T& v, pre_vector) {
BOOST_CHECK(v == real_vector[pos++]);
}
BOOST_REVERSE_FOREACH(const T& v, pre_vector) {
BOOST_CHECK(v == real_vector[--pos]);
}
BOOST_FOREACH(const T& v, const_pre_vector) {
BOOST_CHECK(v == real_vector[pos++]);
}
BOOST_REVERSE_FOREACH(const T& v, const_pre_vector) {
BOOST_CHECK(v == real_vector[--pos]);
}
CDataStream ss1(SER_DISK, 0);
CDataStream ss2(SER_DISK, 0);
ss1 << real_vector;
ss2 << pre_vector;
BOOST_CHECK_EQUAL(ss1.size(), ss2.size());
for (Size s = 0; s < ss1.size(); s++) {
BOOST_CHECK_EQUAL(ss1[s], ss2[s]);
}
}
public:
void resize(Size s) {
real_vector.resize(s);
BOOST_CHECK_EQUAL(real_vector.size(), s);
pre_vector.resize(s);
BOOST_CHECK_EQUAL(pre_vector.size(), s);
