void LoadSavePlugin::registerFormat(FileFormat & fmt)
{
// We insert the format in a very specific location so that the formats
// list is sorted by ascending id, then descending priority.
// We first look for entries with equal or greater ID, then equal or
// lesser priority, and insert before the first item that is of either:
// - Equal ID and lesser or equal priority; or
// - Greater ID
// If we don't find one, we insert before the end iterator, ie append.
if (fmt.formatId == 0) // only for custom plugins
{
uint id;
if (formats.isEmpty())
id = FORMATID_FIRSTUSER;
else
{
QList<FileFormat>::iterator it(formats.begin());
QList<FileFormat>::iterator itEnd(formats.end());
id = FORMATID_FIRSTUSER - 1;
while (it != itEnd)
{
id = qMax(it->formatId, id);
++it;
}
id++;
// id = qMax(static_cast<int>(formats.last().formatId), FORMATID_FIRSTUSER-1);
// id++;
}
fmt.formatId = id;
formats.insert(id, fmt);
}
else
{
QList<FileFormat>::iterator it(formats.begin());
QList<FileFormat>::iterator itEnd(formats.end());
while (it != itEnd)
{
if ( ( (it->formatId == fmt.formatId) && (it->priority <= fmt.priority) ) ||
(it->formatId > fmt.formatId))
break;
++it;
}
formats.insert(it, fmt);
}
//qDebug("Format: Id: %3u, Prio: %3hu, Name: %s", fmt.formatId, fmt.priority, fmt.trName.toLocal8Bit().data() );
//printFormatList(); // DEBUG
}
void
ObjData::printMaterials() const
{
const std::vector<tinyobj::material_t>& materials = this->materials();
std::cout << "# of materials : " << materials.size() << std::endl;
for (size_t i = 0; i < materials.size(); i++) {
printf("material[%u].name = %s\n", i, materials[i].name.c_str());
printf(" material.Ka = (%f, %f ,%f)\n", materials[i].ambient[0], materials[i].ambient[1], materials[i].ambient[2]);
printf(" material.Kd = (%f, %f ,%f)\n", materials[i].diffuse[0], materials[i].diffuse[1], materials[i].diffuse[2]);
printf(" material.Ks = (%f, %f ,%f)\n", materials[i].specular[0], materials[i].specular[1], materials[i].specular[2]);
printf(" material.Tr = (%f, %f ,%f)\n", materials[i].transmittance[0], materials[i].transmittance[1], materials[i].transmittance[2]);
printf(" material.Ke = (%f, %f ,%f)\n", materials[i].emission[0], materials[i].emission[1], materials[i].emission[2]);
printf(" material.Ns = %f\n", materials[i].shininess);
printf(" material.Ni = %f\n", materials[i].ior);
printf(" material.dissolve = %f\n", materials[i].dissolve);
printf(" material.illum = %d\n", materials[i].illum);
printf(" material.map_Ka = %s\n", materials[i].ambient_texname.c_str());
printf(" material.map_Kd = %s\n", materials[i].diffuse_texname.c_str());
printf(" material.map_Ks = %s\n", materials[i].specular_texname.c_str());
printf(" material.map_Ns = %s\n", materials[i].normal_texname.c_str());
std::map<std::string, std::string>::const_iterator it(materials[i].unknown_parameter.begin());
std::map<std::string, std::string>::const_iterator itEnd(materials[i].unknown_parameter.end());
for (; it != itEnd; it++) {
printf(" material.%s = %s\n", it->first.c_str(), it->second.c_str());
}
printf("\n");
}
}
void error(const Context& ctx, const char *format, ...) {
va_list val;
std::list<const TreeNode *>::const_reverse_iterator it(ctx.stack.rbegin()), itEnd(ctx.stack.rend());
printf("%s(%d): Error! ", (*it)->mpLocation->mName.c_str(), (*it)->mLineno);
va_start(val, format);
vprintf(format, val);
va_end(val);
putchar('\n');
int indent = 3;
for(++it; it!=itEnd; ++it) {
const TreeNode& tag = **it;
printf("%*c%s(%d): while processing tag <%s>\n", indent, ' ', tag.mpLocation->mName.c_str(), tag.mLineno, tag.mName.c_str());
indent += 3;
}
indent = 3;
for(it=ctx.invocation_stack.rbegin(), itEnd=ctx.invocation_stack.rend(); it!=itEnd; ++it) {
const TreeNode& tag = **it;
printf("%*c%s(%d): while invoked from tag <%s> (%d children)\n", indent, ' ', tag.mpLocation->mName.c_str(), tag.mLineno, tag.mName.c_str(), tag.mChildren.size());
indent += 3;
}
exit(10);
}
PlotYield DotMapItem::getActualOutput() const
{
MixedOutputOrderFunctor<PlotYield> mixedF(makeYieldP(YIELD_FOOD), OutputUtils<PlotYield>::getDefaultWeights());
typedef std::multiset<DotMapPlotData, PlotDataAdaptor<MixedOutputOrderFunctor<PlotYield> > > SortedPlots;
SortedPlots sortedPlots(mixedF);
for (std::set<DotMapPlotData>::const_iterator pi(plotData.begin()), piEnd(plotData.end()); pi != piEnd; ++pi)
{
sortedPlots.insert(*pi);
}
int surplusFood = cityPlotYield[YIELD_FOOD];
PlotYield totalYield(cityPlotYield);
const int foodPerPop = gGlobals.getFOOD_CONSUMPTION_PER_POPULATION();
for (SortedPlots::iterator it(sortedPlots.begin()), itEnd(sortedPlots.end()); it != itEnd; ++it)
{
if (!it->isSelected)
{
continue;
}
PlotYield thisYield = it->getPlotYield();
surplusFood += thisYield[YIELD_FOOD] - foodPerPop;
if (surplusFood < 0)
{
break;
}
totalYield += thisYield;
}
return totalYield;
}
void ShaderParamSet::setupCameraParam( IShaderParamInput* input , ShaderParamGroup& paramGroup , Camera* camera )
{
for ( ShaderParamList::iterator iter( paramGroup.paramList.begin() ),
itEnd( paramGroup.paramList.end() );
iter != itEnd ; ++iter )
{
switch( iter->content )
{
case SP_CAMERA_POS :
{
Vector3 pos = camera->getWorldPosition();
input->setUniform( iter->varName.c_str() , pos );
}
break;
case SP_CAMERA_Z_FAR:
input->setUniform( iter->varName.c_str() , camera->getZFar() );
break;
case SP_CAMERA_Z_NEAR:
input->setUniform( iter->varName.c_str() , camera->getZNear() );
break;
case SP_CAMERA_VIEW:
input->setUniform( iter->varName.c_str() , camera->getViewMatrix() );
break;
case SP_CAMERA_VIEW_PROJ :
case SP_CAMERA_WORLD :
break;
}
}
}
void Graph::Print() const
{
std::cout << "-----------------------------" << std::endl;
std::cout << "vertices (" << m_nV << ")" << std::endl;
for (size_t v = 0; v < m_vertices.size(); ++v)
{
const GraphVertex & currentVertex = m_vertices[v];
if (!m_vertices[v].m_deleted)
{
std::cout << currentVertex.m_name << "\t";
std::set<long>::const_iterator ed(currentVertex.m_edges.begin());
std::set<long>::const_iterator itEnd(currentVertex.m_edges.end());
for(; ed != itEnd; ++ed)
{
std::cout << "(" << m_edges[*ed].m_v1 << "," << m_edges[*ed].m_v2 << ") ";
}
std::cout << std::endl;
}
}
std::cout << "vertices (" << m_nE << ")" << std::endl;
for (size_t e = 0; e < m_edges.size(); ++e)
{
const GraphEdge & currentEdge = m_edges[e];
if (!m_edges[e].m_deleted)
{
std::cout << currentEdge.m_name << "\t("
<< m_edges[e].m_v1 << ","
<< m_edges[e].m_v2 << ") "<< std::endl;
}
}
}
void ShaderParamSet::setupGlobalParam( IShaderParamInput* input , ShaderParamGroup& paramGroup )
{
for ( ShaderParamList::iterator iter( paramGroup.paramList.begin() ),
itEnd( paramGroup.paramList.end() );
iter != itEnd ; ++iter )
{
switch( iter->content )
{
case SP_WORLD:
input->setUniform( iter->varName.c_str() , getWorldMatrix() );
break;
case SP_VIEW :
input->setUniform( iter->varName.c_str() , getViewMatrix() );
break;
case SP_PROJ :
input->setUniform( iter->varName.c_str() , getProjectMatrix() );
break;
case SP_WORLD_INV :
input->setUniform( iter->varName.c_str() , getInvWorldMatrix() );
break;
case SP_VIEW_PROJ :
input->setUniform( iter->varName.c_str() , getViewProjMatrix() );
break;
case SP_WVP :
input->setUniform( iter->varName.c_str() , getWVPMatrix() );
break;
case SP_WORLD_VIEW:
input->setUniform( iter->varName.c_str() , getWorldViewMatrix() );
break;
//case SP_AMBIENT_LIGHT:
// input->setUniform( iter->varName.c_str() , scene->setAmbientLight() );
}
}
}
bool TColorMatch::findNodeMatch(int nodeX,int nodeY,int* out_x0,int* out_y0,frg_TMatchType* out_matchType)const{
const TUInt32 keyValue=m_nodeKeys[nodeY*m_nodeWidth+nodeX];
std::pair<TMatchMap::const_iterator,TMatchMap::const_iterator> itPair(m_matchMap.equal_range(keyValue));
TMatchMap::const_iterator it(itPair.first);
TMatchMap::const_iterator itEnd(itPair.second);
if (it==itEnd) return false;
const int subX0=nodeX*kFrg_ClipWidth;
const int subY0=nodeY*kFrg_ClipHeight;
bool isFindedMatch=false;
int bestX0=-1;
int bestY0=-1;
frg_TMatchType best_matchType;
for (;it!=itEnd;++it){
int cur_x0=unpackMatchX(it->second);
int cur_y0=unpackMatchY(it->second);
frg_TMatchType cur_matchType;
bool cur_isMatched=isMatchAt(subX0,subY0,kFrg_ClipWidth,kFrg_ClipHeight,cur_x0,cur_y0,&cur_matchType);
if (cur_isMatched){
isFindedMatch=true;
bestX0=cur_x0;
bestY0=cur_y0;
best_matchType=cur_matchType;
break;// ok finded one; 也可以继续寻找某种标准下更好的匹配,但可能会慢些.
}
}
if (isFindedMatch){
*out_x0=bestX0;
*out_y0=bestY0;
*out_matchType=best_matchType;
}
return isFindedMatch;
}
void dump_stack(Context& ctx) {
std::list<const TreeNode *>::reverse_iterator it(ctx.stack.rbegin()), itEnd(ctx.stack.rend());
printf("Current execution stack:\n");
int indent = 3;
for(++it; it!=itEnd; ++it) {
const TreeNode& tag = **it;
printf("%*c%s(%d): processing <%s>\n", indent, ' ', tag.mpLocation->mName.c_str(), tag.mLineno, tag.mName.c_str());
indent += 3;
}
indent = 3;
std::list<TreeNode *>::reverse_iterator it2(ctx.construction_stack.rbegin()), it2End(ctx.construction_stack.rend());
for(; it2!=it2End; ++it2) {
const TreeNode& tag = **it2;
printf("%*c%s(%d): while creating tag <%s>\n", indent, ' ', tag.mpLocation->mName.c_str(), tag.mLineno, tag.mName.c_str());
indent += 3;
}
indent = 3;
for(it=ctx.invocation_stack.rbegin(), itEnd=ctx.invocation_stack.rend(); it!=itEnd; ++it) {
const TreeNode& tag = **it;
printf("%*c%s(%d): while invoked from tag <%s>\n", indent, ' ', tag.mpLocation->mName.c_str(), tag.mLineno, tag.mName.c_str());
indent += 3;
}
}
const QStringList LoadSavePlugin::getExtensionsForColors(const int id)
{
QList<FileFormat>::const_iterator it(findFormat(id));
QList<FileFormat>::const_iterator itEnd(formats.constEnd());
QStringList filterList;
// We know the list is sorted by id, then priority, so we can just take the
// highest priority entry for each ID, and we can start with the first entry
// in the list.
//First, check if we even have any plugins to load with
if (it != itEnd)
{
if ((it->load) && (it->colorReading))
filterList.append(it->fileExtensions);
unsigned int lastID = it->formatId;
++it;
for ( ; it != itEnd ; ++it)
{
// Find the next load/save (as appropriate) plugin for the next format type
if (((it->load) && (it->colorReading)) && (it->formatId > lastID))
{
// And add it to the filter list, since we know it's
// the highest priority because of the sort order.
filterList.append(it->fileExtensions);
lastID = it->formatId;
}
}
}
else
qDebug("%s", tr("No File Loader Plugins Found").toLocal8Bit().data());
// Avoid duplicate entries in the list
QSet<QString> fSet = filterList.toSet();
filterList = fSet.toList();
qSort(filterList);
return filterList;
}
void Writer::Visit(const String& stringElement) {
m_ostr << '"';
const std::string& s = stringElement;
std::string::const_iterator it(s.begin()),
itEnd(s.end());
for (; it != itEnd; ++it)
{
switch (*it)
{
case '"': m_ostr << "\\\""; break;
case '\\': m_ostr << "\\\\"; break;
case '\b': m_ostr << "\\b"; break;
case '\f': m_ostr << "\\f"; break;
case '\n': m_ostr << "\\n"; break;
case '\r': m_ostr << "\\r"; break;
case '\t': m_ostr << "\\t"; break;
//case '\u': m_ostr << ""; break; ??
default: m_ostr << *it; break;
}
}
m_ostr << '"';
}
/**
* @brief Remove all collision boxes within given box. Box is aligned with axes and uses the same frame id.
* @param center Clearing box center
* @param size Clearing box sizes
* @return Number of removed boxes.
*/
long srs_env_model::CCMapPlugin::removeInsideBox( const tBoxPoint & center, const tBoxPoint & size, tBoxVec & boxes )
{
boost::mutex::scoped_lock lock( m_lockData );
// Create data copy
tBoxVec buffer( boxes.begin(), boxes.end() );
// Clear output
boxes.clear();
// Compute testing box extents
tBoxPoint extents;
extents.x = size.x / 2.0; extents.y = size.y / 2.0; extents.z = size.z / 2.0;
long counter(0);
// Add excluded boxes to the data
tBoxVec::iterator it, itEnd( buffer.end() );
for( it = buffer.begin(); it != itEnd; ++it )
{
if( abs( it->center.x - center.x ) > (it->extents.x + extents.x ) ||
abs( it->center.y - center.y ) > (it->extents.y + extents.y ) ||
abs( it->center.z - center.z ) > (it->extents.z + extents.z ) )
{
boxes.push_back( *it );
++counter;
}
}
// Return number of removed boxes
return buffer.size() - counter;
}
PlotYield DotMapItem::getOutput(PlayerTypes playerType, YieldWeights yieldWeights) const
{
YieldPriority yieldPriority;
yieldPriority.assign(-1);
yieldPriority[0] = YIELD_FOOD;
MixedOutputOrderFunctor<PlotYield> mixedF(yieldPriority, yieldWeights);
typedef std::multiset<DotMapPlotData, PlotDataAdaptor<MixedOutputOrderFunctor<PlotYield> > > SortedPlots;
SortedPlots sortedPlots(mixedF);
for (std::set<DotMapPlotData>::const_iterator pi(plotData.begin()), piEnd(plotData.end()); pi != piEnd; ++pi)
{
sortedPlots.insert(*pi);
}
int surplusFood = cityPlotYield[YIELD_FOOD];
PlotYield totalYield(cityPlotYield);
const int foodPerPop = gGlobals.getFOOD_CONSUMPTION_PER_POPULATION();
for (SortedPlots::iterator it(sortedPlots.begin()), itEnd(sortedPlots.end()); it != itEnd; ++it)
{
PlotYield thisYield = it->getPlotYield();
surplusFood += thisYield[YIELD_FOOD] - foodPerPop;
if (surplusFood < 0)
{
break;
}
totalYield += thisYield;
}
return totalYield;
}
void srs_env_model::CCollisionObjectPlugin::newMapDataCB( SMapWithParameters & par )
{
m_data->header.frame_id = m_coFrameId;
m_data->header.stamp = par.currentTime;
m_data->id = "map";
m_ocFrameId = par.frameId;
tf::StampedTransform ocToCoTf;
m_bConvert = m_ocFrameId != m_coFrameId;
/// We need no transformation - frames are the same...
if( ! m_bConvert )
return;
// Get transform
try {
// Transformation - to, from, time, waiting time
m_tfListener.waitForTransform(m_coFrameId, m_ocFrameId,
par.currentTime, ros::Duration(5));
m_tfListener.lookupTransform(m_coFrameId, m_ocFrameId,
par.currentTime, ocToCoTf);
} catch (tf::TransformException& ex) {
ROS_ERROR_STREAM("Transform error: " << ex.what() << ", quitting callback");
PERROR("Transform error.");
return;
}
Eigen::Matrix4f ocToPcTM;
// Get transformation matrix
pcl_ros::transformAsMatrix(ocToCoTf, ocToPcTM);
// Disassemble translation and rotation
m_ocToCoRot = ocToPcTM.block<3, 3> (0, 0);
m_ocToCoTrans = ocToPcTM.block<3, 1> (0, 3);
// Initialize leaf iterators
tButServerOcTree & tree( par.map->octree );
srs_env_model::tButServerOcTree::leaf_iterator it, itEnd( tree.end_leafs() );
// Crawl through nodes
for ( it = tree.begin_leafs(m_crawlDepth); it != itEnd; ++it)
{
// Node is occupied?
if (tree.isNodeOccupied(*it))
{
handleOccupiedNode(it, par);
}// Node is occupied?
} // Iterate through octree
m_DataTimeStamp = par.currentTime;
invalidate();
}
void srs_env_model::CMarkerArrayPlugin::newMapDataCB(SMapWithParameters & par)
{
// each array stores all cubes of a different size, one for each depth level:
m_data->markers.resize(par.treeDepth + 1);
m_ocFrameId = par.frameId;
// Get octomap parameters
par.map->octree.getMetricMin(m_minX, m_minY, m_minZ);
par.map->octree.getMetricMax(m_maxX, m_maxY, m_maxZ);
m_bTransform = m_ocFrameId != m_markerArrayFrameId;
// Is transform needed?
if( ! m_bTransform )
return;
ros::Time timestamp( par.currentTime );
tf::StampedTransform ocToMarkerArrayTf;
// Get transform
try {
// Transformation - to, from, time, waiting time
m_tfListener.waitForTransform(m_markerArrayFrameId, m_ocFrameId,
timestamp, ros::Duration(5));
m_tfListener.lookupTransform(m_markerArrayFrameId, m_ocFrameId,
timestamp, ocToMarkerArrayTf);
} catch (tf::TransformException& ex) {
ROS_ERROR_STREAM("MarkerArrayPlugin: Transform error - " << ex.what() << ", quitting callback");
PERROR( "Transform error.");
return;
}
Eigen::Matrix4f ocToMarkerArrayTM;
// Get transformation matrix
pcl_ros::transformAsMatrix(ocToMarkerArrayTf, ocToMarkerArrayTM);
// Disassemble translation and rotation
m_ocToMarkerArrayRot = ocToMarkerArrayTM.block<3, 3> (0, 0);
m_ocToMarkerArrayTrans = ocToMarkerArrayTM.block<3, 1> (0, 3);
tButServerOcTree & tree( par.map->octree );
srs_env_model::tButServerOcTree::leaf_iterator it, itEnd( tree.end_leafs() );
// Crawl through nodes
for ( it = tree.begin_leafs(m_crawlDepth); it != itEnd; ++it)
{
handleNode(it, par);
} // Iterate through octree
handlePostNodeTraversal( par );
}
std::vector<openstudio::path> ScriptFolderListView::folders() const {
std::vector<openstudio::path> result;
std::map<openstudio::path, std::string>::const_iterator it(m_displayNames.begin());
std::map<openstudio::path, std::string>::const_iterator itEnd(m_displayNames.end());
for (; it != itEnd; ++it) {
result.push_back(it->first);
}
return result;
}
//---------------------------- PROTECTED -----------------------------//
void RuleExtensionMixin::ExecuteExtensions(const DataObject &object)
{
IRuleEngine::StringHash::const_iterator it, itEnd(hash_end());
for(it = hash_begin(); it != itEnd; ++it)
{
RULE.Execute(it->second, object);
}
}
void *VDJITAllocator::Allocate(size_t len) {
len = (len + 15) & ~(size_t)15;
FreeChunks::iterator itMark(mNextChunk), itEnd(mFreeChunks.end()), it(itMark);
if (it == itEnd)
it = mFreeChunks.begin();
for(;;) {
for(; it!=itEnd; ++it) {
if (it->second >= len) {
it->second -= len;
void *p = (char *)it->first + it->second;
if (!it->second) {
if (mNextChunk == it)
++mNextChunk;
mFreeChunks.erase(it);
}
return p;
}
}
if (itEnd == itMark)
break;
it = mFreeChunks.begin();
itEnd = itMark;
}
size_t alloclen = (len + mAllocationGranularity - 1) & ~(mAllocationGranularity - 1);
void *p = VirtualAlloc(NULL, alloclen, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (p) {
try {
Allocations::iterator itA(mAllocations.insert(Allocations::value_type(p, alloclen)).first);
try {
if (len < alloclen)
mFreeChunks.insert(FreeChunks::value_type((char *)p + len, alloclen - len));
} catch(...) {
mAllocations.erase(itA);
throw;
}
} catch(...) {
VirtualFree(p, 0, MEM_RELEASE);
p = NULL;
}
}
return p;
}
bool VDUIJobLogDialog::OnLoaded() {
IVDLogWindowControl *pLogWin = VDGetILogWindowControl(GetDlgItem(mhdlg, IDC_LOG));
for(VDAutoLogger::tEntries::const_iterator it(mLogEnts.begin()), itEnd(mLogEnts.end()); it!=itEnd; ++it) {
const VDAutoLogger::Entry& ent = *it;
pLogWin->AddEntry(ent.severity, ent.text);
}
return VDDialogFrameW32::OnLoaded();
}
const TreeAttribute *TreeNode::Attrib(const std::string& s) const {
Attributes::const_iterator it(mAttribs.begin()), itEnd(mAttribs.end());
for(; it!=itEnd; ++it) {
if ((*it).mName == s)
return &*it;
}
return NULL;
}
VDFilterFrameBufferCacheLinkNode *VDFilterFrameBuffer::GetCacheReference(VDFilterFrameCache *cache) {
for(Caches::iterator it(mCaches.begin()), itEnd(mCaches.end()); it != itEnd; ++it) {
VDFilterFrameBufferCacheLinkNode *linkNode = *it;
if (linkNode->mpCache == cache)
return linkNode;
}
return NULL;
}
void Group::printGroup()
{
std::map<std::string, Entity>::const_iterator itBegin(m_entities.begin()),
itEnd(m_entities.end());
for(;itBegin != itEnd; itBegin++)
{
std::cout << itBegin->first << std::endl;
}
}
void JobListView::setNumberOfFilePathParts(int number)
{
if (number == m_numberOfFilePathParts)
return;
m_numberOfFilePathParts = number;
ItemMap::const_iterator it(m_items.begin());
ItemMap::const_iterator itEnd(m_items.end());
for (; it != itEnd; ++it)
it.value()->updateFileName();
}
// static debugging function - prints the human readable format list
void LoadSavePlugin::printFormatList()
{
qDebug("Current format list:");
QList<FileFormat>::const_iterator it(formats.constBegin());
QList<FileFormat>::const_iterator itEnd(formats.constEnd());
for ( ; it != itEnd ; ++it)
{
qDebug(" Format: Id: %3u, Prio: %3hu, Name: %s", it->formatId, it->priority, it->trName.toLocal8Bit().data() );
}
qDebug("Done");
}
CGUIWindow::~CGUIWindow()
{
std::vector<CGuiElement*>::iterator it(m_GuiElementsVector.begin());
std::vector<CGuiElement*>::iterator itEnd(m_GuiElementsVector.end());
while (it != itEnd)
{
delete (*it);
it++;
}
m_GuiElementsVector.clear();
}
QList<FileFormat>::iterator
LoadSavePlugin::findFormat(unsigned int id, LoadSavePlugin* plug, QList<FileFormat>::iterator it)
{
QList<FileFormat>::iterator itEnd(formats.end());
for ( ; it != itEnd ; ++it)
{
if ((it->formatId == id) && ((plug == nullptr) || (plug == it->plug)))
return it;
}
return itEnd;
}
QList<FileFormat>::iterator
LoadSavePlugin::findFormat(const QString& extension, LoadSavePlugin* plug, QList<FileFormat>::iterator it)
{
QList<FileFormat>::iterator itEnd(formats.end());
for ( ; it != itEnd ; ++it)
{
if ((it->fileExtensions.contains(extension.toLower())) && ((plug == nullptr) || (plug == it->plug)) )
return it;
}
return itEnd;
}
void help() {
wprintf(L"\n");
wprintf(L"Available tests:\n");
for(Tests::const_iterator it(g_tests.begin()), itEnd(g_tests.end()); it!=itEnd; ++it) {
const TestInfo& ent = *it;
wprintf(L"\t%hs%s\n", ent.mpName, ent.mbAutoRun ? L"" : L"*");
}
wprintf(L"\tAll\n");
}
int Buffer::deleteBytes( Buffer::Iterator& itStart, int intLen ) {
// Make a copy of our iterator
Buffer::Iterator itEnd( itStart );
// Move the iterator up intLen of positions
pageBuffer.mNext( itEnd.itPage, intLen );
// Preform the deletion
return deleteBytes( itStart, itEnd );
}
Frameserver::~Frameserver() {
for(tSessions::iterator it(mSessions.begin()), itEnd(mSessions.end()); it!=itEnd; ++it) {
FrameserverSession *pSession = (*it).second;
delete pSession;
}
mSessions.clear();
filters.DeinitFilters();
filters.DeallocateBuffers();
}
