void test_list_set_with_stale_handles()
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
Range verts;
const int num_vtx = 40;
std::vector<double> coords( 3*num_vtx, 0.0 );
rval = mb.create_vertices( &coords[0], num_vtx, verts );
CHECK_ERR(rval);
CHECK_EQUAL(num_vtx, (int)verts.size());
EntityHandle set;
rval = mb.create_meshset( MESHSET_ORDERED, set );
CHECK_ERR(rval);
rval = mb.add_entities( set, verts );
CHECK_ERR(rval);
std::vector<EntityHandle> dead_verts;
for (int i = num_vtx/4; i < num_vtx; i += num_vtx/4 ) {
Range::iterator j = verts.begin();
j += i;
dead_verts.push_back( *j );
}
rval = mb.delete_entities( &dead_verts[0], dead_verts.size() );
CHECK_ERR(rval);
Core moab2;
Interface& mb2 = moab2;
EntityHandle file_set;
read_write_file( mb, mb2, &file_set );
Range sets;
rval = mb2.get_entities_by_type( 0, MBENTITYSET, sets );
CHECK_ERR(rval);
CHECK_EQUAL( 2, (int)sets.size() );
EntityHandle other_set = sets.front() == file_set ? sets.back() : sets.front();
std::vector<EntityHandle> list;
rval = mb2.get_entities_by_handle( other_set, list );
CHECK_ERR(rval);
CHECK_EQUAL( verts.size() - dead_verts.size(), list.size() );
}
cloth::SwFabric::SwFabric( SwFactory& factory, uint32_t numParticles,
Range<const uint32_t> phases, Range<const uint32_t> sets,
Range<const float> restvalues, Range<const uint32_t> indices,
Range<const uint32_t> anchors, Range<const float> tetherLengths, uint32_t id)
: mFactory(factory),
mNumParticles(numParticles),
mTetherLengthScale(1.0f),
mId(id)
{
// should no longer be prefixed with 0
PX_ASSERT(sets.front() != 0);
#if defined(PX_WINDOWS)
const uint32_t kSimdWidth = 8; // avx
#elif defined(PX_X360) || defined(PX_PS3)
const uint32_t kSimdWidth = 8; // unrolled loop
#else
const uint32_t kSimdWidth = 4;
#endif
// consistency check
PX_ASSERT(sets.back() == restvalues.size());
PX_ASSERT(restvalues.size()*2 == indices.size());
PX_ASSERT(mNumParticles > *maxElement(indices.begin(), indices.end()));
PX_ASSERT(mNumParticles + kSimdWidth-1 <= USHRT_MAX);
mPhases.assign(phases.begin(), phases.end());
mSets.reserve(sets.size() + 1);
mSets.pushBack(0); // prefix with 0
mOriginalNumRestvalues = uint32_t(restvalues.size());
// padd indices for SIMD
const uint32_t* iBegin = indices.begin(), *iIt = iBegin;
const float* rBegin = restvalues.begin(), *rIt = rBegin;
const uint32_t* sIt, *sEnd = sets.end();
for(sIt = sets.begin(); sIt != sEnd; ++sIt)
{
const float* rEnd = rBegin + *sIt;
const uint32_t* iEnd = iBegin + *sIt * 2;
uint32_t numConstraints = uint32_t(rEnd - rIt);
for(; rIt != rEnd; ++rIt)
mRestvalues.pushBack(*rIt);
for(; iIt != iEnd; ++iIt)
mIndices.pushBack(uint16_t(*iIt));
// add dummy indices to make multiple of 4
for(; numConstraints &= kSimdWidth-1; ++numConstraints)
{
mRestvalues.pushBack(-FLT_MAX);
uint32_t index = mNumParticles + numConstraints - 1;
mIndices.pushBack(uint16_t(index));
mIndices.pushBack(uint16_t(index));
}
mSets.pushBack(uint32_t(mRestvalues.size()));
}
// trim overallocations
RestvalueContainer(mRestvalues.begin(), mRestvalues.end()).swap(mRestvalues);
Vector<uint16_t>::Type(mIndices.begin(), mIndices.end()).swap(mIndices);
// tethers
PX_ASSERT(anchors.size() == tetherLengths.size());
// pad to allow for direct 16 byte (unaligned) loads
mTethers.reserve(anchors.size() + 2);
for(; !anchors.empty(); anchors.popFront(), tetherLengths.popFront())
mTethers.pushBack(SwTether(uint16_t(anchors.front()), tetherLengths.front()));
mFactory.mFabrics.pushBack(this);
}
static PostDataStatus ParseMultipartPost(std::string &completedFile,
struct mg_connection *connection,
const IHttpHandler::Arguments& headers,
const std::string& contentType,
ChunkStore& chunkStore)
{
std::string boundary = "--" + contentType.substr(multipartLength);
std::string postData;
PostDataStatus status = ReadBody(postData, connection, headers);
if (status != PostDataStatus_Success)
{
return status;
}
/*for (IHttpHandler::Arguments::const_iterator i = headers.begin(); i != headers.end(); i++)
{
std::cout << "Header [" << i->first << "] = " << i->second << "\n";
}
printf("CHUNK\n");*/
typedef IHttpHandler::Arguments::const_iterator ArgumentIterator;
ArgumentIterator requestedWith = headers.find("x-requested-with");
ArgumentIterator fileName = headers.find("x-file-name");
ArgumentIterator fileSizeStr = headers.find("x-file-size");
if (requestedWith != headers.end() &&
requestedWith->second != "XMLHttpRequest")
{
return PostDataStatus_Failure;
}
size_t fileSize = 0;
if (fileSizeStr != headers.end())
{
try
{
fileSize = boost::lexical_cast<size_t>(fileSizeStr->second);
}
catch (boost::bad_lexical_cast)
{
return PostDataStatus_Failure;
}
}
typedef boost::find_iterator<std::string::iterator> FindIterator;
typedef boost::iterator_range<char*> Range;
//chunkStore.Print();
try
{
FindIterator last;
for (FindIterator it =
make_find_iterator(postData, boost::first_finder(boundary));
it!=FindIterator();
++it)
{
if (last != FindIterator())
{
Range part(&last->back(), &it->front());
Range content = boost::find_first(part, "\r\n\r\n");
if (/*content != Range()*/!content.empty())
{
Range c(&content.back() + 1, &it->front() - 2);
size_t chunkSize = c.size();
if (chunkSize > 0)
{
const char* chunkData = &c.front();
if (fileName == headers.end())
{
// This file is stored in a single chunk
completedFile.resize(chunkSize);
if (chunkSize > 0)
{
memcpy(&completedFile[0], chunkData, chunkSize);
}
return PostDataStatus_Success;
}
else
{
return chunkStore.Store(completedFile, chunkData, chunkSize, fileName->second, fileSize);
}
}
}
}
last = it;
}
}
catch (std::length_error)
{
return PostDataStatus_Failure;
}
return PostDataStatus_Pending;
}
