void ISession2D_Shape::BuildPolyAlgo()
{
myPolyAlgo = new HLRBRep_PolyAlgo();
TopTools_ListIteratorOfListOfShape anIterator(myListOfShape);
for (;anIterator.More();anIterator.Next()) myPolyAlgo->Load(anIterator.Value());
myPolyAlgo->Projector(myProjector);
myPolyAlgo->Update();
}
Stepper::VariableVector::size_type
Stepper::getVariableIndex( Variable const* aVariable ) const
{
VariableVector::const_iterator
anIterator( std::find( theVariableVector.begin(),
theVariableVector.end(),
aVariable ) );
return anIterator - theVariableVector.begin();
}
void ISession2D_Shape::BuildAlgo()
{
myAlgo = new HLRBRep_Algo();
TopTools_ListIteratorOfListOfShape anIterator(myListOfShape);
for (;anIterator.More();anIterator.Next()) myAlgo->Add(anIterator.Value(),myNbIsos);
myAlgo->Projector(myProjector);
myAlgo->Update();
myAlgo->Hide();
}
VariableReference const&
Process::getVariableReference( String const& aVariableReferenceName ) const
{
VariableReferenceVector::const_iterator anIterator(
findVariableReference( aVariableReferenceName ) );
if( anIterator != theVariableReferenceVector.end() )
{
return *anIterator;
}
else
{
THROW_EXCEPTION_INSIDE( NotFound,
asString() + ": VariableReference ["
+ aVariableReferenceName
+ "] not found in this Process" );
}
}
VariableReference const&
Process::getVariableReference( Integer anID ) const
{
VariableReferenceVector::const_iterator anIterator(
findVariableReference( anID ) );
if( anIterator != theVariableReferenceVector.end() )
{
return *anIterator;
}
else
{
THROW_EXCEPTION_INSIDE( NotFound,
asString() + ": VariableReference #"
+ stringCast( anID )
+ " not found in this Process" );
}
}
void Stepper::updateVariableVector()
{
typedef std::map< Variable*, VariableReference, std::less< Variable* > >
PtrVariableReferenceMap;
typedef Process::VariableReferenceVector VariableReferenceVector;
PtrVariableReferenceMap aPtrVariableReferenceMap;
for( ProcessVector::const_iterator i( theProcessVector.begin());
i != theProcessVector.end() ; ++i )
{
VariableReferenceVector const& aVariableReferenceVector(
(*i)->getVariableReferenceVector() );
// for all the VariableReferences
for( VariableReferenceVector::const_iterator j(
aVariableReferenceVector.begin() );
j != aVariableReferenceVector.end(); ++j )
{
VariableReference const& aNewVariableReference( *j );
Variable* aVariablePtr( aNewVariableReference.getVariable() );
PtrVariableReferenceMap::iterator
anIterator( aPtrVariableReferenceMap.find( aVariablePtr ) );
if( anIterator == aPtrVariableReferenceMap.end() )
{
aPtrVariableReferenceMap.insert(
PtrVariableReferenceMap::value_type(
aVariablePtr, aNewVariableReference ) );
}
else
{
VariableReference& aVariableReference( anIterator->second );
aVariableReference.setIsAccessor(
aVariableReference.isAccessor()
|| aNewVariableReference.isAccessor() );
aVariableReference.setCoefficient(
abs( aVariableReference.getCoefficient() )
+ abs( aNewVariableReference.getCoefficient() ) );
}
}
}
VariableReferenceVector aVariableReferenceVector;
aVariableReferenceVector.reserve( aPtrVariableReferenceMap.size() );
// I want select2nd... but use a for loop for portability.
for( PtrVariableReferenceMap::const_iterator
i( aPtrVariableReferenceMap.begin() );
i != aPtrVariableReferenceMap.end() ; ++i )
{
aVariableReferenceVector.push_back( i->second );
}
VariableReferenceVector::iterator aReadOnlyVariableReferenceIterator =
std::partition( aVariableReferenceVector.begin(),
aVariableReferenceVector.end(),
std::mem_fun_ref( &VariableReference::isMutator ) );
VariableReferenceVector::iterator aReadWriteVariableReferenceIterator =
std::partition( aVariableReferenceVector.begin(),
aReadOnlyVariableReferenceIterator,
std::not1(
std::mem_fun_ref( &VariableReference::isAccessor )
) );
theVariableVector.clear();
theVariableVector.reserve( aVariableReferenceVector.size() );
std::transform( aVariableReferenceVector.begin(),
aVariableReferenceVector.end(),
std::back_inserter( theVariableVector ),
std::mem_fun_ref( &VariableReference::getVariable ) );
theReadWriteVariableOffset = aReadWriteVariableReferenceIterator
- aVariableReferenceVector.begin();
theReadOnlyVariableOffset = aReadOnlyVariableReferenceIterator
- aVariableReferenceVector.begin();
VariableVector::iterator aReadWriteVariableIterator =
theVariableVector.begin() + theReadWriteVariableOffset;
VariableVector::iterator aReadOnlyVariableIterator =
theVariableVector.begin() + theReadOnlyVariableOffset;
// For each part of the vector, sort by memory address.
// This is an optimization.
std::sort( theVariableVector.begin(), aReadWriteVariableIterator );
std::sort( aReadWriteVariableIterator, aReadOnlyVariableIterator );
std::sort( aReadOnlyVariableIterator, theVariableVector.end() );
}
