bool check ()
{
TMap :: iterator Iter , Iter2;
Map2 = Map;
string next;
int len = Ans.length () , len1;
for ( Iter = Map2.begin (); Iter != Map2.end (); Iter ++ )
for ( ; Iter->second; ) {
Iter -> second --;
len1 = Iter->first.length ();
if ( len1 > len ) return false;
if ( Ans.substr ( 0 , len1 ) == Iter->first ) {
next = Ans.substr ( len1 , len - len1 );
Iter2 = Map2.find ( next );
if ( Iter2 == Map2.end () || Iter2->second == 0 ) break;
Iter2->second --;
continue;
}
if ( Ans.substr ( len - len1 , len1 ) == Iter->first ) {
next = Ans.substr ( 0 , len - len1 );
Iter2 = Map2.find ( next );
if ( Iter2 == Map2.end () || Iter2->second == 0 ) break;
Iter2->second --;
continue;
}
return false;
}
return true;
}
void CTestRangeMap::TestRangeMap(void) const
{
Filling("CRangeMap");
typedef CRangeMultimap<CConstRef<CObject> > TMap;
typedef TMap::const_iterator TMapCI;
TMap m;
// fill
for ( int count = 0; count < m_RangeNumber; ) {
TRange range = RandomRange();
m.insert(TMap::value_type(range, CConstRef<CObject>(0)));
++count;
Added(range);
}
if ( m_PrintSize ) {
Filled(m.size());
// Stat(m.stat());
}
for ( TMapCI i = m.begin(); i; ++i ) {
FromAll(i.GetInterval());
}
size_t scannedCount = 0;
for ( int count = 0; count < m_ScanCount; ++count ) {
for ( int pos = 0; pos <= m_Length + 2*m_RangeLength;
pos += m_ScanStep ) {
TRange range;
range.Set(pos, pos + m_ScanLength - 1);
StartFrom(range);
for ( TMapCI i = m.begin(range); i; ++i ) {
From(range, i.GetInterval());
++scannedCount;
}
}
}
PrintTotalScannedNumber(scannedCount);
End();
}
//----------------------------------------------------------------------------
void CIsoSurface::MakeUnique (std::vector<TVector3D>& rkVA,
std::vector<TriangleKey>& rkTA)
{
int iVQuantity = (int)rkVA.size();
int iTQuantity = (int)rkTA.size();
if ( iVQuantity == 0 || iTQuantity == 0 )
return;
// use a hash table to generate unique storage
VMap kVMap;
VMapIterator pkVIter;
for (int iV = 0, iNextVertex = 0; iV < iVQuantity; iV++)
{
// keep only unique vertices
std::pair<VMapIterator,bool> kResult = kVMap.insert( std::make_pair(rkVA[iV],iNextVertex) );
if ( kResult.second == true )
iNextVertex++;
}
std::cerr << "Found " << kVMap.size() << " vertices" << std::endl;
// use a hash table to generate unique storage
TMap kTMap;
TMapIterator pkTIter;
for (int iT = 0, iNextTriangle = 0; iT < iTQuantity; iT++)
{
// replace old vertex indices by new ones
TriangleKey& rkTri = rkTA[iT];
pkVIter = kVMap.find(rkVA[rkTri.V[0]]);
assert( pkVIter != kVMap.end() );
rkTri.V[0] = pkVIter->second;
pkVIter = kVMap.find(rkVA[rkTri.V[1]]);
assert( pkVIter != kVMap.end() );
rkTri.V[1] = pkVIter->second;
pkVIter = kVMap.find(rkVA[rkTri.V[2]]);
assert( pkVIter != kVMap.end() );
rkTri.V[2] = pkVIter->second;
// keep only unique triangles
std::pair<TMapIterator,bool> kResult = kTMap.insert(
std::make_pair(rkTri,iNextTriangle));
if ( kResult.second == true )
iNextTriangle++;
}
// pack the vertices
rkVA.resize(kVMap.size());
for (pkVIter = kVMap.begin(); pkVIter != kVMap.end(); pkVIter++)
rkVA[pkVIter->second] = pkVIter->first;
// pack the triangles
rkTA.resize(kTMap.size());
for (pkTIter = kTMap.begin(); pkTIter != kTMap.end(); pkTIter++)
rkTA[pkTIter->second] = pkTIter->first;
}
/**
* insert
*/
BOOST_AUTO_TEST_CASE_TEMPLATE(stest_insert, TMap, test_types) {
// insert x values, insert them again, check values
using char_tt = typename TMap::char_type;
const size_t nb_values = 100000;
TMap set;
typename TMap::iterator it;
bool inserted;
for(size_t i = 0; i < nb_values; i++) {
std::tie(it, inserted) = set.insert(utils::get_key<char_tt>(i));
BOOST_CHECK_EQUAL(it.key(), (utils::get_key<char_tt>(i)));
BOOST_CHECK(inserted);
}
BOOST_CHECK_EQUAL(set.size(), nb_values);
for(size_t i = 0; i < nb_values; i++) {
std::tie(it, inserted) = set.insert(utils::get_key<char_tt>(i));
BOOST_CHECK_EQUAL(it.key(), (utils::get_key<char_tt>(i)));
BOOST_CHECK(!inserted);
}
for(size_t i = 0; i < nb_values; i++) {
it = set.find(utils::get_key<char_tt>(i));
BOOST_CHECK(it != set.end());
BOOST_CHECK_EQUAL(it.key(), (utils::get_key<char_tt>(i)));
}
for(auto it = set.begin(); it != set.end(); ++it) {
auto it_find = set.find(it.key());
BOOST_CHECK(it_find != set.end());
BOOST_CHECK_EQUAL(it_find.key(), it.key());
}
}
const_iterator begin(void) const {
return const_iterator(m_Map.begin());
}
iterator begin(void) {
return iterator(m_Map.begin());
}