/******************* FUNCTION *********************/
void ProjectActionOld::genItLoopCCode ( ostream& out, const CMRProjectContext& context, int depth ) const
{
CMRProjectContext localContext(&context);
//errors
assert(name == "cmrSubBlock" && description == "cmrIteratorLoop");
//search the related iterator definition
const CMRProjectEntity * entity = context.parent->find(eq->latexEntity);
if (entity == NULL)
{
cerr << "Can't find the definition of iterator " << eq->compute << " in current context." << endl;
abort();
}
const CMRProjectIterator * iterator = dynamic_cast<const CMRProjectIterator*>(entity);
if (iterator == NULL)
{
cerr << "Cuation, expect iterator " << eq->compute << " but get another type." << endl;
context.printDebug();
abort();
}
assert(iterator != NULL);
CMRProjectLocalVariable localVar(eq->compute,eq->compute);
localContext.addEntry(&localVar);
out << genCCodeIndent(depth) << "for (int " << eq->compute << " = " << iterator->start << " ; " << eq->compute << " < " << iterator->end << " ; " << eq->compute << "++ )" <<endl;
out << genCCodeIndent(depth) << "{" << endl;
for (ConstIterator it = getFirstChild() ; ! it.isEnd() ; ++it)
it->genCCode(out,it->context,depth+1);
//it->genCCode(out,localContext,depth+1);
out << genCCodeIndent(depth) << "}" << endl;
//checkContext(localContext);
}
bool KEntryMap::revertEntry(const QByteArray& group, const QByteArray& key, KEntryMap::SearchFlags flags)
{
Q_ASSERT((flags & KEntryMap::SearchDefaults) == 0);
Iterator entry = findEntry(group, key, flags);
if (entry != end()) {
//qDebug() << "reverting" << entry.key() << " = " << entry->mValue;
if (entry->bReverted) { // already done before
return false;
}
KEntryKey defaultKey(entry.key());
defaultKey.bDefault = true;
//qDebug() << "looking up default entry with key=" << defaultKey;
const ConstIterator defaultEntry = constFind(defaultKey);
if (defaultEntry != constEnd()) {
Q_ASSERT(defaultEntry.key().bDefault);
//qDebug() << "found, update entry";
*entry = *defaultEntry; // copy default value, for subsequent lookups
} else {
entry->mValue = QByteArray();
}
entry->bDirty = true;
entry->bReverted = true; // skip it when writing out to disk
//qDebug() << "Here's what we have now:" << *this;
return true;
}
return false;
}
float get_mean(Image::Pointer im)
{
ConstIterator it;
it = ConstIterator(im, im->GetLargestPossibleRegion());
float mean = 0, N=0;
try
{
while(!it.IsAtEnd())
{
if(it.Get()!=0)
{
mean = N/(N+1)*mean + it.Get()/(N+1);
++N;
}
++it;
}
}
catch( itk::ExceptionObject & err)
{
std::cout<<"Error calculating mean, iterator error"<<std::endl;
std::cout<<err<<std::endl;
}
return mean;
}
/******************* FUNCTION *********************/
void ProjectActionOld::genRootElemCCode ( ostream& out, const CMRProjectContext& context, int depth ) const
{
CMRProjectContext localContext(&context);
for (ConstIterator it = getFirstChild() ; ! it.isEnd() ; ++it)
it->genCCode(out,it->context,depth+1);
//it->genCCode(out,localContext,depth+1);
//checkContext(localContext);
}
inline typename ListType::ConstIterator largestFragment(const ListType& src)
{
typedef typename ListType::ConstIterator ConstIterator;
ConstIterator result = src.begin();
for( ConstIterator i = result; i != src.end(); ++i )
if( result->length() < i->length() ) result = i;
return result;
}
BreakpointId BreakHandler::findBreakpointByAddress(quint64 address) const
{
ConstIterator it = m_storage.constBegin(), et = m_storage.constEnd();
for ( ; it != et; ++it)
if (it->data.address == address || it->response.address == address)
return it.key();
return BreakpointId();
}
BreakpointId BreakHandler::findBreakpointByFunction(const QString &functionName) const
{
ConstIterator it = m_storage.constBegin(), et = m_storage.constEnd();
for ( ; it != et; ++it)
if (it->data.functionName == functionName)
return it.key();
return BreakpointId();
}
BreakpointId BreakHandler::findBreakpointByFileAndLine(const QString &fileName,
int lineNumber, bool useMarkerPosition)
{
ConstIterator it = m_storage.constBegin(), et = m_storage.constEnd();
for ( ; it != et; ++it)
if (it->isLocatedAt(fileName, lineNumber, useMarkerPosition))
return it.key();
return BreakpointId();
}
AnnotationStatistics FeatureMap::getAnnotationStatistics() const
{
AnnotationStatistics result;
for (ConstIterator iter = this->begin(); iter != this->end(); ++iter)
{
result += iter->getAnnotationState();
}
return result;
}
Int64
Header::writeTo (OStream &os, bool isTiled) const
{
//
// Write a "magic number" to identify the file as an image file.
// Write the current file format version number.
//
Xdr::write <StreamIO> (os, MAGIC);
int version = isTiled ? makeTiled (EXR_VERSION) : EXR_VERSION;
Xdr::write <StreamIO> (os, version);
//
// Write all attributes. If we have a preview image attribute,
// keep track of its position in the file.
//
Int64 previewPosition = 0;
const Attribute *preview =
findTypedAttribute <PreviewImageAttribute> ("preview");
for (ConstIterator i = begin(); i != end(); ++i)
{
//
// Write the attribute's name and type.
//
Xdr::write <StreamIO> (os, i.name());
Xdr::write <StreamIO> (os, i.attribute().typeName());
//
// Write the size of the attribute value,
// and the value itself.
//
StdOSStream oss;
i.attribute().writeValueTo (oss, version);
std::string s = oss.str();
Xdr::write <StreamIO> (os, (int) s.length());
if (&i.attribute() == preview)
previewPosition = os.tellp();
os.write (s.data(), s.length());
}
//
// Write zero-length attribute name to mark the end of the header.
//
Xdr::write <StreamIO> (os, "");
return previewPosition;
}
const char* MessageHeader::get(const char* key) const
{
for (ConstIterator it = begin(); it != end(); ++it)
{
if (compareIgnoreCase(key, it->name()) == 0)
return it->value();
}
return 0;
}
void MessageHeader::remove(const char* key)
{
if( ! *key)
throw std::invalid_argument("header key is NULL");
char* p = eptr();
ConstIterator it = begin();
while (it != end())
{
if (compareIgnoreCase(key, it->name()) == 0)
{
std::size_t slen = it->value() - it->name() + std::strlen(it->value()) + 1;
std::memcpy(
const_cast<char*>(it->name()),
it->name() + slen,
p - it->name() + slen);
p -= slen;
it.fixup();
}
else
++it;
}
_endOffset = p - _rawdata;
}
QString TemplateDocument::finalText() const
{
QString ready = d->templateText;
typedef QMap<QString, QString>::ConstIterator ConstIterator;
ConstIterator end = d->templateEntries.constEnd();
for (ConstIterator i = d->templateEntries.constBegin(); i != end; i++) {
ready.replace(QLatin1Char('%') + i.key() + QLatin1Char('%'), i.value());
}
d->processTemplateIncludes(ready);
return ready;
}
BreakpointId BreakHandler::findWatchpoint(const BreakpointParameters &data) const
{
ConstIterator it = m_storage.constBegin(), et = m_storage.constEnd();
for ( ; it != et; ++it)
if (it->data.isWatchpoint()
&& it->data.address == data.address
&& it->data.size == data.size
&& it->data.bitpos == data.bitpos)
return it.key();
return BreakpointId();
}
typename ListType::FragmentType
selectBlock(const ListType& src, typename ListType::FSizeType blockSize,
const AvailableType* available )
{
typedef typename ListType::FragmentType FragmentType;
typedef typename ListType::FSizeType FSizeType;
typedef typename ListType::ConstIterator ConstIterator;
if( src.empty() ) return FragmentType( 0,
::std::numeric_limits< FSizeType >::max() );
::std::deque< FSizeType > blocks;
for( ConstIterator selectIterator = src.begin();
selectIterator != src.end(); ++selectIterator )
{
FSizeType blockBegin = selectIterator->begin() / blockSize;
FSizeType blockEnd = ( selectIterator->end() - 1 ) / blockSize;
if ( selectIterator->begin() % blockSize )
{
// the start of a block is complete, but part is missing
if ( !available || available[ blockBegin ] )
{
return FragmentType( selectIterator->begin(),
::std::min( selectIterator->end(),
blockSize * ( blockBegin + 1 ) ) );
}
++blockBegin;
}
if ( blockBegin <= blockEnd && selectIterator->end() % blockSize
&& selectIterator->end() < src.limit() )
{
// the end of a block is complete, but part is missing
if ( !available || available[ blockEnd ] )
{
return FragmentType( blockEnd * blockSize,
selectIterator->end() );
}
--blockEnd;
}
// this fragment contains one or more aligned empty blocks
if( blockEnd != ~0ULL ) for( ; blockBegin <= blockEnd; ++blockBegin )
{
if( !available || available[ blockBegin ] )
{
blocks.push_back( blockBegin );
}
}
}
if( blocks.empty() ) return FragmentType( 0,
::std::numeric_limits< FSizeType >::max() );
FSizeType blockBegin = blocks[ ::std::rand() % blocks.size() ] * blockSize;
return FragmentType( blockBegin, ::std::min( blockBegin + blockSize, src.limit() ) );
}
bool SVGTransformList::concatenate(AffineTransform& result) const
{
if (isEmpty())
return false;
ConstIterator it = begin();
ConstIterator itEnd = end();
for (; it != itEnd; ++it)
result *= it->matrix();
return true;
}
void QFragmentMap::check()
{
Q_ASSERT((head->node_count == 0 && head->root == 0)
|| (head->node_count != 0 && head->root != 0 && F(head->root).parent == 0));
ConstIterator it = begin();
int key = 0;
for (; it != end(); ++it) {
Q_ASSERT(key == it.key());
key += (*it)->size;
}
}
VBHostedAllocator::~VBHostedAllocator()
{
ConstIterator<IUnknown*> pCurrent;
m_Allocator.FreeHeap();
pCurrent = m_COMReleaseList.GetConstIterator();
while (pCurrent.MoveNext())
{
pCurrent.Current()->Release();
}
m_COMReleaseList.Clear();
}
bool Window::getFocusList(WidgetList& wl) const {
for(ConstIterator i = begin(); i != end(); i++) if(i->valid()) {
EmbeddedWindow* ew = dynamic_cast<EmbeddedWindow*>(i->get());
if(!ew) {
if(i->get()->canFocus()) wl.push_back(i->get());
}
else {
if(ew->getWindow()) ew->getWindow()->getFocusList(wl);
}
}
return wl.size() != 0;
}
QString RejestracjaWydanychPsow::listaPrzydzielenPsow() const
{
QString listaPrzydzielenPsow;
QTextStream strumienWyjscie (&listaPrzydzielenPsow);
ConstIterator it = constBegin();
for ( ; it != constEnd(); ++it)
{ strumienWyjscie << "["
<< it.key()->toString() // klucz
<< "]" << " : ["
<< it.value()->toString() // wartość
<< "]" << endl;
}
return listaPrzydzielenPsow;
}
bool Window::getEmbeddedList(WindowList& wl) const {
for(ConstIterator i = begin(); i != end(); i++) if(i->valid()) {
EmbeddedWindow* ew = dynamic_cast<EmbeddedWindow*>(i->get());
if(!ew || !ew->getWindow()) continue;
else {
wl.push_back(ew->getWindow());
ew->getWindow()->getEmbeddedList(wl);
}
}
return wl.size() != 0;
}
QStringList HostConfigMap::save( KConfigBase &config ) const
{
QStringList hostList;
for ( ConstIterator it = begin(); it != end(); ++it ) {
QString host = it.key();
hostList << host;
config.setGroup( "Host " + host );
( *it ).save( config );
}
return hostList;
}
String SVGTransformList::valueAsString() const
{
StringBuilder builder;
ConstIterator it = begin();
ConstIterator itEnd = end();
while (it != itEnd) {
builder.append(it->valueAsString());
++it;
if (it != itEnd)
builder.append(' ');
}
return builder.toString();
}
/******************* FUNCTION *********************/
void ProjectActionOld::printDebug(int depth) const
{
for (int i = 0 ; i < depth ; i++)
cout << "\t";
if (name == "cmrEquation")
{
cout << this->eq->latexName << " = " << this->eq->compute << endl;
} else {
if (eq != NULL)
cout << name << " - " << description << " - " << eq->compute << ":" << endl;
else
cout << name << " - " << description << ":" << endl;
for (ConstIterator it = getFirstChild() ; ! it.isEnd() ; ++it)
it->printDebug(depth+1);
}
}
String SVGLengthList::valueAsString() const {
StringBuilder builder;
ConstIterator it = begin();
ConstIterator itEnd = end();
if (it != itEnd) {
builder.append(it->valueAsString());
++it;
for (; it != itEnd; ++it) {
builder.append(' ');
builder.append(it->valueAsString());
}
}
return builder.toString();
}
// The topmost Window always has this method called, instead of the embedded window directly.
bool Window::setFocused(const Widget* widget) {
// TODO: I've turned on the warn() here, but perhaps I shouldn't? I need to define
// the conditions under which it's okay to call setFocus() with a NULL widget.
if(!widget) {
warn() << "Window [" << _name << "] can't focus a NULL Widget." << std::endl;
return false;
}
ConstIterator i = std::find(begin(), end(), widget);
bool found = false;
if(i == end()) {
// We couldn't find the widget in the toplevel, so lets see if one of our
// EmbeddedWindow objects has it.
WindowList wl;
getEmbeddedList(wl);
for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) {
ConstIterator ii = std::find(w->get()->begin(), w->get()->end(), widget);
if(ii != w->get()->end()) {
found = true;
i = ii;
}
}
}
else found = true;
if(!found) {
warn()
<< "Window [" << _name
<< "] couldn't find the Widget [" << widget->getName()
<< "] in it's object list." << std::endl
;
return false;
}
_setFocused(i->get());
return true;
}
bool
ChannelList::operator == (const ChannelList &other) const
{
ConstIterator i = begin();
ConstIterator j = other.begin();
while (i != end() && j != other.end())
{
if (!(i.channel() == j.channel()))
return false;
++i;
++j;
}
return i == end() && j == other.end();
}
void
ChannelList::layers (set <string> &layerNames) const
{
layerNames.clear();
for (ConstIterator i = begin(); i != end(); ++i)
{
string layerName = i.name();
size_t pos = layerName.rfind ('.');
if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
{
layerName.erase (pos);
layerNames.insert (layerName);
}
}
}
//! Search for step \c inStep starting at position \c inPos.
void XML::ConstFinder::search(XML::ConstIterator inPos, unsigned int inStep) {
// stop recursion?
if(!inPos || inStep >= mSteps.size()) return;
// process current step
if(mSteps[inStep] == "..") {
// move up to parent
if(inPos != mNode) {
if(inStep+1 < mSteps.size()) {
if(mSteps[inStep+1] == "..") search(inPos->getParent(), inStep+1);
else {
for(ConstIterator lPos = inPos->getParent()->getFirstChild(); lPos; ++lPos)
search(lPos, inStep+1);
}
} else mMatches.push(inPos->getParent());
}
} else if(mSteps[inStep] == "") {
// walk tree in level order
queue<ConstIterator> lSearchQueue;
lSearchQueue.push(inPos);
while(!lSearchQueue.empty()) {
// get next node
ConstIterator lPos = lSearchQueue.front();
lSearchQueue.pop();
// push all its children onto the search queue
for(ConstIterator lChild = lPos->getFirstChild(); lChild; ++lChild) lSearchQueue.push(lChild);
// if not last step, search recursively
if(inStep+1 < mSteps.size()) search(lPos, inStep+1);
else mMatches.push(lPos);
}
} else {
if(mSteps[inStep] == "*" || inPos->getValue() == mSteps[inStep]) {
// found a match
if(inStep+1 < mSteps.size()) {
if(mSteps[inStep+1] == "..") search(inPos, inStep+1);
else {
for(ConstIterator lPos = inPos->getFirstChild(); lPos; ++lPos)
search(lPos, inStep+1);
}
} else mMatches.push(inPos);
}
}
}
bool AggregationClass::referencesData( const void* a_pContainer, const phantom::data& a_Data ) const
{
ConstIterator* pIterator = begin(a_pContainer);
o_assert(m_pAggregateClass->pointerType() == pIterator->getValueType());
bool result = false;
while(pIterator->hasNext())
{
const void* ptr = pIterator->pointer();
if(pIterator->getValueType()->referencesData(ptr, a_Data))
{
return true;
}
}
release(pIterator);
return result;
}
