std::list<LedgerEntry>::const_iterator
LedgerStateRoot::Impl::loadOffers(StatementContext& prep,
                                  std::list<LedgerEntry>& offers) const
{
    std::string actIDStrKey;
    unsigned int sellingAssetType, buyingAssetType;
    std::string sellingAssetCode, buyingAssetCode, sellingIssuerStrKey,
        buyingIssuerStrKey;
    soci::indicator sellingAssetCodeIndicator, buyingAssetCodeIndicator,
        sellingIssuerIndicator, buyingIssuerIndicator;

    LedgerEntry le;
    le.data.type(OFFER);
    OfferEntry& oe = le.data.offer();

    auto& st = prep.statement();
    st.exchange(soci::into(actIDStrKey));
    st.exchange(soci::into(oe.offerID));
    st.exchange(soci::into(sellingAssetType));
    st.exchange(soci::into(sellingAssetCode, sellingAssetCodeIndicator));
    st.exchange(soci::into(sellingIssuerStrKey, sellingIssuerIndicator));
    st.exchange(soci::into(buyingAssetType));
    st.exchange(soci::into(buyingAssetCode, buyingAssetCodeIndicator));
    st.exchange(soci::into(buyingIssuerStrKey, buyingIssuerIndicator));
    st.exchange(soci::into(oe.amount));
    st.exchange(soci::into(oe.price.n));
    st.exchange(soci::into(oe.price.d));
    st.exchange(soci::into(oe.flags));
    st.exchange(soci::into(le.lastModifiedLedgerSeq));
    st.define_and_bind();
    st.execute(true);

    auto iterNext = offers.cend();
    while (st.got_data())
    {
        oe.sellerID = KeyUtils::fromStrKey<PublicKey>(actIDStrKey);
        processAsset(oe.selling, (AssetType)sellingAssetType,
                     sellingIssuerStrKey, sellingIssuerIndicator,
                     sellingAssetCode, sellingAssetCodeIndicator);
        processAsset(oe.buying, (AssetType)buyingAssetType, buyingIssuerStrKey,
                     buyingIssuerIndicator, buyingAssetCode,
                     buyingAssetCodeIndicator);

        if (iterNext == offers.cend())
        {
            iterNext = offers.emplace(iterNext, le);
        }
        else
        {
            offers.emplace_back(le);
        }
        st.fetch();
    }

    return iterNext;
}
 void emplace_front(Args&&... args) {
     const bool need_reinit = (min_ == data_.cend());
     data_.emplace_front(std::forward<Args>(args)...);
     if (need_reinit || data_.front() < *min_) {
         min_ = pointer_to_first();
     }
 }
Exemple #3
0
void ContactList::initContacts(const std::list<ContactGroup> &contactGroups)
{
    for(auto it = contactGroups.cbegin(); it != contactGroups.cend(); ++it)
    {
        const ContactGroup &group = *it;
        auto groupName = group.name;
        Wt::WPanel * panel = new Wt::WPanel;
        panel->setTitle(groupName);
        panel->setCollapsible(true);
        panel->setCentralWidget(new Wt::WContainerWidget());
        mContactPanels.insert(std::make_pair(group,panel));

        for(auto contactIt = group.contacts.cbegin(); contactIt != group.contacts.cend(); ++contactIt)
        {

            const ContactInfo &info = *contactIt;
            addContact(info.uin,info.showName);
            mContacts.push_back(info);

        }

    }

    showFullList();

}
	bool Map::CanMoveTo(const GameObject* movingObject, const Rectangle& position, const std::list<GameObject*>& objects) const
	{
		if (IsInMapBounds(position) == false)
			return false;

		const MapCell* cell = GetCellFromRealPosition(position.Left(), position.Top());
		if (cell->GetIsObstacle() == true)
			return false;
		cell = GetCellFromRealPosition(position.Right() - 1, position.Top());
		if (cell->GetIsObstacle() == true)
			return false;
		cell = GetCellFromRealPosition(position.Left(), position.Bottom() - 1);
		if (cell->GetIsObstacle() == true)
			return false;
		cell = GetCellFromRealPosition(position.Right() - 1, position.Bottom() - 1);
		if (cell->GetIsObstacle() == true)
			return false;

		for (std::list<GameObject*>::const_iterator it = objects.cbegin(); it != objects.cend(); ++it)
		{
			if ((*it != movingObject) && ((*it)->IsCollidable() == true) && (*it)->IsCollidingWith(position) == true)
				return false;
		}
		return true;
	}
void Harness::onMessages(const std::list<omx_message> &messages) {
    Mutex::Autolock autoLock(mLock);
    for (std::list<omx_message>::const_iterator it = messages.cbegin(); it != messages.cend(); ) {
        mMessageQueue.push_back(*it++);
    }
    mMessageAddedCondition.signal();
}
 /// \b Complexity: amort O(1)
 void pop_back() {
     const bool need_reinit = (min_ == pointer_to_last());
     data_.pop_back();
     if (need_reinit) {
         min_ = std::min_element(data_.cbegin(), data_.cend());
     }
 }
void print_list(std::list<int> list, const char *key_string)
{
	std::cout << key_string << std::endl; 
	for (auto it = list.cbegin(); it != list.cend(); it++) {
		std::cout << *it;
	}
	std::cout << std::endl;
}
    queue_with_min& operator=(const queue_with_min& q) {
        if (this == &q) {
            return *this;
        }

        data_ = q.data_;
        min_ = std::min_element(data_.cbegin(), data_.cend());
        return *this;
    }
std::list<std::string>
StatementPrinter::generateStatementLines(const std::list<Transaction>& transactions)
{
        std::list<std::string> statementLines;
        for (auto it = transactions.cbegin(); it != transactions.cend(); ++it) {
                this->runningBalance += it->amount();
                statementLines.push_back(generateStatementLine(*it));
        }
        return statementLines;
}
Exemple #10
0
	/**
	 * Common function for command service callbacks.
	 *
	 * NOTE: success is bool in messages, but has unsigned char type in C++
	 */
	bool send_command_long_and_wait(uint16_t command, uint8_t confirmation,
			float param1, float param2,
			float param3, float param4,
			float param5, float param6,
			float param7,
			unsigned char &success, uint8_t &result) {
		unique_lock lock(mutex);

		/* check transactions */
		for (auto it = ack_waiting_list.cbegin();
				it != ack_waiting_list.cend(); it++)
			if ((*it)->expected_command == command) {
				ROS_WARN_THROTTLE_NAMED(10, "cmd", "Command %u alredy in progress", command);
				return false;
			}

		//! @note APM always send COMMAND_ACK, while PX4 never.
		bool is_ack_required = (confirmation != 0 || uas->is_ardupilotmega()) && !uas->is_px4();
		if (is_ack_required)
			ack_waiting_list.push_back(new CommandTransaction(command));

		command_long(command, confirmation,
				param1, param2,
				param3, param4,
				param5, param6,
				param7);

		if (is_ack_required) {
			auto it = ack_waiting_list.begin();
			for (; it != ack_waiting_list.end(); it++)
				if ((*it)->expected_command == command)
					break;

			if (it == ack_waiting_list.end()) {
				ROS_ERROR_NAMED("cmd", "CommandTransaction not found for %u", command);
				return false;
			}

			lock.unlock();
			bool is_not_timeout = wait_ack_for(*it);
			lock.lock();

			success = is_not_timeout && (*it)->result == MAV_RESULT_ACCEPTED;
			result = (*it)->result;

			delete *it;
			ack_waiting_list.erase(it);
		}
		else {
			success = true;
			result = MAV_RESULT_ACCEPTED;
		}

		return true;
	}
QuadNode::QuadNode(int id, int x, int y, int width, int height, std::list<NodeObject*> listNodeObject)
{
	_id = id;
	_bouding._x = x;
	_bouding._y = y;
	_bouding._w = width;
	_bouding._h = height;
	

	std::move(listNodeObject.cbegin(), listNodeObject.cend(), std::back_inserter(_listNodeObject));
}
void ChatroomFrontpage::OnUserInfoChange(const std::list<nim::UserNameCard> &uinfos)
{
	for (auto iter = uinfos.cbegin(); iter != uinfos.cend(); iter++)
	{
		if (nim_ui::LoginManager::GetInstance()->IsEqual(iter->GetAccId()))
		{
			InitHeader();
			break;
		}
	}
}
void AutoMagic::installAutoMagic(SeparatistaDocument *pDocument)
{
	DEBUG_STATIC_METHOD;

	typedef struct
	{
		void (*pfnCreateAutoMagicFactory)(SeparatistaDocument *pDocument, const wchar_t *pBasePath, const wchar_t *pWatchPath, const wchar_t *pValuePath);
		const wchar_t *pBasePath;
		const wchar_t *pWatchPath;
		const wchar_t *pValuePath;
	} AutoMagicInfo;

	// Insert new automagic here
	std::unordered_map<std::wstring, const std::initializer_list<AutoMagicInfo>> autoMagicMap =
	{
		{
			Separatista::camt_053_001_02::Namespace,
				{
					// Order is important here, value elements being watched should be created last
				}
		},
		{
			Separatista::pain_001_001_03::Namespace,
				{
					// Order is important here, value elements being watched should be created last
				}
		},
		{
			Separatista::pain_008_001_02::Namespace, 
				{
					// Order is important here, value elements being watched should be created last
					{
						AutoMagicFactory<SumAutoMagic>::Create, TEXT("CstmrDrctDbtInitn"), TEXT("PmtInf/NbOfTxs"), TEXT("GrpHdr/NbOfTxs")
					},
					{
						AutoMagicFactory<SumAutoMagic>::Create, TEXT("CstmrDrctDbtInitn"), TEXT("PmtInf/CtrlSum"), TEXT("GrpHdr/CtrlSum")
					},
					{
						AutoMagicFactory<CountAutoMagic>::Create, TEXT("CstmrDrctDbtInitn/PmtInf"), TEXT("DrctDbtTxInf"), TEXT("NbOfTxs")
					},
					{
						AutoMagicFactory<SumAutoMagic>::Create, TEXT("CstmrDrctDbtInitn/PmtInf"), TEXT("DrctDbtTxInf/InstdAmt"), TEXT("CtrlSum")
					}
				} 
		}
	};

	const std::list<AutoMagicInfo> infoList = autoMagicMap[pDocument->getNamespaceURI()];
	for (auto info = infoList.cbegin(); info != infoList.cend(); info++)
	{
		info->pfnCreateAutoMagicFactory(pDocument, info->pBasePath, info->pWatchPath, info->pValuePath);
	}
}
Exemple #14
0
	void handle_command_ack(const mavlink::mavlink_message_t *msg, mavlink::common::msg::COMMAND_ACK &ack)
	{
		lock_guard lock(mutex);
		for (auto it = ack_waiting_list.cbegin();
				it != ack_waiting_list.cend(); it++)
			if ((*it)->expected_command == ack.command) {
				(*it)->result = ack.result;
				(*it)->ack.notify_all();
				return;
			}

		ROS_WARN_THROTTLE_NAMED(10, "cmd", "CMD: Unexpected command %u, result %u",
				ack.command, ack.result);
	}
bool Explosion::CanExplode(const Rectangle& zone, std::list<GameObject*>& objects, const Map& map, bool& block)
{
    block = false;
    if (map.IsInMapBounds(zone) == false)
        return false;
    for (std::list<GameObject*>::const_iterator it = objects.cbegin(); it != objects.cend(); ++it)
    {
        if ((*it)->IsCollidingWith(zone) == true)
        {
            return (*it)->CanExplode(block);
        }
    }
    return true;
}
Exemple #16
0
int compare(std::vector<int> &vi, std::list<int> &li) {
    int ret = 0;
    auto i = vi.cbegin();
    auto j = li.cbegin();
    for (; i != vi.cend() && j != li.cend(); i++, j++) {
        if (*i > *j) {
            ret = 1;
            break;
        }
        else if (*i < *j) {
            ret = -1;
            break;
        }
    }

    if (ret != 0)
        return ret;
    else if (i != vi.cend())
        return 1;
    else if (j != li.cend())
        return -1;
    else
        return 0;
}
Exemple #17
0
	void handle_command_ack(const mavlink_message_t *msg, uint8_t sysid, uint8_t compid) {
		mavlink_command_ack_t ack;
		mavlink_msg_command_ack_decode(msg, &ack);

		lock_guard lock(mutex);
		for (auto it = ack_waiting_list.cbegin();
				it != ack_waiting_list.cend(); it++)
			if ((*it)->expected_command == ack.command) {
				(*it)->result = ack.result;
				(*it)->ack.notify_all();
				return;
			}

		ROS_WARN_THROTTLE_NAMED(10, "cmd", "CMD: Unexpected command %u, result %u",
				ack.command, ack.result);
	}
Exemple #18
0
bool User::GetUserNameCardOnline(const std::list<std::string>& accids, const GetUserNameCardCallback& cb, const std::string& json_extension /*= ""*/)
{
	if (accids.empty())
		return false;

	GetUserNameCardCallback* cb_pointer = nullptr;
	if (cb)
	{
		cb_pointer = new GetUserNameCardCallback(cb);
	}

	Json::Value values;
	for (auto iter = accids.cbegin(); iter != accids.cend(); ++iter)
		values.append(*iter);

	NIM_SDK_GET_FUNC(nim_user_get_user_name_card_online)(values.toStyledString().c_str(), json_extension.c_str(), &CallbackGetUserNameCard, cb_pointer);

	return true;
}
		bool compareAdjVertices(const std::list<Edge>& adj, const std::list<int>& adjVert, int vertexToExclude) {
			bool result = true;
			
			std::list<int>::const_iterator adjVertIt = adjVert.cbegin();
			for (std::list<Edge>::const_iterator adjit = adj.cbegin(); adjit != adj.cend() && adjVertIt != adjVert.cend(); ++adjit, ++adjVertIt) {
				auto w = adjit->other(vertexToExclude);
				auto v = *adjVertIt;

				if (w == v)
					continue;

				result = false;
				break;


			}

			return result;
		}
Exemple #20
0
std::size_t CsvInterface::findColumn(std::string const& line, char delim, std::string const& column_name)
{
	std::list<std::string> const fields = BaseLib::splitString(line, delim);
	if (fields.empty())
		return std::numeric_limits<std::size_t>::max();

	std::size_t count(0);
	for (auto it = fields.cbegin(); it != fields.cend(); ++it)
	{
		if ((*it).compare(column_name) == 0)
			break;
		else
			count++;
	}

	if (count == fields.size())
		return std::numeric_limits<std::size_t>::max();

	return count;
}
iter
search(const std::list<int> & li, const int num) {
	static iter sp = li.cbegin();	// last time found
	const static iter iter_end = li.cend();

	if(sp == iter_end)
		sp = li.cbegin();

	while(*sp != num && sp != iter_end) {
		if(*sp > num) {
			--sp;
			if(*sp < num)
				sp = iter_end;
		} else {
			++sp;
			if(*sp > num)
				sp = iter_end;
		}//if-else
	}//while

	return sp;
}//search
Exemple #22
0
bool DiaBinarySaver::saveEnities(LPCTSTR lpszPathName, const std::list<DiaEntity*>& entities) const
{
	std::fstream file(lpszPathName, std::ios_base::out|std::ios_base::binary);

	for (std::list<DiaEntity*>::const_iterator it = entities.cbegin() ; it != entities.cend(); it++)
	{
		const DiaEntity* e = *it;	
		DiaEntity::Type type = e->type();

		switch (type)
		{
			case DiaEntity::Ellipse :	{ saveEllipse(e, file); break; }
			case DiaEntity::Rectangle :	{ saveRectangle(e, file); break; }
			case DiaEntity::Triangle :	{ saveTriangle(e, file); break; }
			case DiaEntity::Arrow :		{ saveArrow(e, file); break; }
			default: break;
		}		
	}

	file.close();

	return true;
}
Exemple #23
0
void printl(std::list<int> &li) {
    for (auto i = li.cbegin(); i != li.cend(); i++)
        std::cout << *i << " ";
}
 queue_with_min& operator=(std::initializer_list<value_type> il) {
     data_ = il;
     min_ = std::min_element(data_.cbegin(), data_.cend());
     return *this;
 }
 queue_with_min(const queue_with_min& q)
     : data_(q.data_)
     , min_( std::min_element(data_.cbegin(), data_.cend()) )
 {}
 /// \b Complexity: O(1)
 queue_with_min() noexcept
     : data_()
     , min_(data_.cend())
 {}
 /// \b Complexity: O(N), in case of POD type up to O(1)
 void clear() noexcept {
     data_.clear();
     min_ = data_.cend();
 }
Exemple #28
0
bool IGFrame::ManageSelection (const IGLibrary::SELECTIONPARAMS& selParams, const std::list<POINT>& lPts)
{
	// Request thread access
	if (!RequestAccess ())
		return false;
	CxImage *pCurrentLayer = GetWorkingLayer();
	if (!pCurrentLayer)
		return false;
	int nCurLayerId = (int)pCurrentLayer->GetId();
	int nCurLayerWidth = (int)pCurrentLayer->GetWidth();
	int nCurLayerHeight = (int)pCurrentLayer->GetHeight();
	_ASSERTE ((nCurLayerId >= 0) && L"Current layer is not identified");
	if (nCurLayerId < 0)
		return false;
	bool bRes = false;
	POINT ptTopLeft = {0, 0};
	POINT ptBottomRight = {-1, -1};
	IGSELECTIONENUM eSelectionType = selParams.eSelectionType;
	if (((eSelectionType & IGSELECTION_SQUARE) == IGSELECTION_SQUARE) ||
		((eSelectionType & IGSELECTION_LASSO) == IGSELECTION_LASSO))
	{
		if (lPts.size() > 0)
		{
			bool bAllEqual = true;
			for (list <POINT>::const_iterator itPt = lPts.cbegin(); itPt != lPts.cend(); ++itPt)
			{
				if (((*itPt).x != lPts.front().x) || ((*itPt).y != lPts.front().y))
					bAllEqual = false;
			}
			if (bAllEqual)
				eSelectionType = IGSELECTION_CLEAR;
		}
	}
	if ((eSelectionType & IGSELECTION_CLEAR) == IGSELECTION_CLEAR)
	{
		if ((eSelectionType & IGSELECTION_INVERT) == IGSELECTION_INVERT)
			bRes = pCurrentLayer->SelectionInvert();
		else
			bRes = pCurrentLayer->SelectionDelete();
	}
	else
	{
		if ((eSelectionType & IGSELECTION_REPLACE) == IGSELECTION_REPLACE)
			pCurrentLayer->SelectionClear();	
		BYTE level = ((eSelectionType & IGSELECTION_REMOVE) == IGSELECTION_REMOVE) ? 0 : 255;

		std::list<POINT> lConvertedPts (lPts); 
		// convert IG coordinates to Cx coordinates
		IGConvertible::FromIGtoCxCoords(lConvertedPts, pCurrentLayer->GetHeight());
	
		// apply selection
		if ((eSelectionType & IGSELECTION_SQUARE) == IGSELECTION_SQUARE)
		{
			if (lPts.size() != 2)
				return false;	
			// read rectangle coordinates
			ptTopLeft = lConvertedPts.front();
			ptBottomRight = lConvertedPts.back();
			int nPosX = ptTopLeft.x;
			int nPosY = ptBottomRight.y;
			RECT rcSel;
			rcSel.left = nPosX; rcSel.top = nPosY;
			nPosX = ptBottomRight.x;
			nPosY = ptTopLeft.y;
			rcSel.right = nPosX; rcSel.bottom = nPosY;
			// adjust rectangle orientation
			int nWidth = rcSel.right - rcSel.left;
			int nHeight = rcSel.top - rcSel.bottom;
			nWidth = (nWidth < 0) ? -1 * nWidth : nWidth;
			nHeight = (nHeight < 0) ? -1 * nHeight : nHeight;
			rcSel.left = (rcSel.left < rcSel.right) ? rcSel.left : rcSel.right;
			rcSel.bottom = (rcSel.bottom < rcSel.top) ? rcSel.bottom : rcSel.top;
			rcSel.right = rcSel.left + nWidth;
			rcSel.top = rcSel.bottom + nHeight;
			// test if rectangle is inside the frame
			if ((rcSel.right < 0) || (rcSel.left >= nCurLayerWidth)
				|| (rcSel.top < 0) || (rcSel.bottom >= nCurLayerHeight))
				return false;	// selection out of bounds
			// adjust bounds
			rcSel.left = (rcSel.left < 0) ? 0 : rcSel.left;
			rcSel.right = (rcSel.right >= nCurLayerWidth) ? nCurLayerWidth - 1 : rcSel.right;
			rcSel.bottom = (rcSel.bottom < 0) ? 0 : rcSel.bottom;
			rcSel.top = (rcSel.top >= nCurLayerHeight) ? nCurLayerHeight - 1 : rcSel.top;
			// add the selection
			bRes = pCurrentLayer->SelectionAddRect (rcSel, level);
		}
		else if ((eSelectionType & IGSELECTION_LASSO) == IGSELECTION_LASSO)
		{
			bRes = pCurrentLayer->SelectionAddPolygon (lConvertedPts, level);
		}
		else if ((eSelectionType & IGSELECTION_MAGIC) == IGSELECTION_MAGIC)
		{
			bRes = pCurrentLayer->SelectionAddMagic (lConvertedPts.front(), level, selParams.nTolerance);
		}
		else if ((eSelectionType & IGSELECTION_FACES) == IGSELECTION_FACES)
		{
			bRes = pCurrentLayer->SelectionAddFaces (level);
		}
		else if ((eSelectionType & IGSELECTION_EYES) == IGSELECTION_EYES)
		{
			bRes = pCurrentLayer->SelectionAddEyes (level);
		}
		else if ((eSelectionType & IGSELECTION_MOUTH) == IGSELECTION_MOUTH)
		{
			bRes = pCurrentLayer->SelectionAddMouth (level);
		}
		else if ((eSelectionType & IGSELECTION_NOZE) == IGSELECTION_NOZE)
		{
			bRes = pCurrentLayer->SelectionAddNoze (level);
		}
		else if ((eSelectionType & IGSELECTION_LPE) == IGSELECTION_LPE)
		{
			bRes = pCurrentLayer->SelectionAddLPE (lConvertedPts, level);
		}
		if (ptBottomRight.x < ptTopLeft.x)
		{
			int nSwap = ptTopLeft.x;
			ptTopLeft.x = ptBottomRight.x;
			ptBottomRight.x = nSwap;
		}
		if (ptBottomRight.y < ptTopLeft.y)
		{
			int nSwap = ptTopLeft.y;
			ptTopLeft.y = ptBottomRight.y;
			ptBottomRight.y = nSwap;
		}
		if (ptTopLeft.x < 0)
			ptTopLeft.x = 0;
		if (ptTopLeft.y < 0)
			ptTopLeft.y = 0;
		if (ptBottomRight.x >= nCurLayerWidth)
			ptBottomRight.x = nCurLayerWidth - 1;
		if (ptBottomRight.y >= nCurLayerHeight)
			ptBottomRight.y = nCurLayerHeight - 1;
	}
	if (!pCurrentLayer->SelectionIsValid())
		pCurrentLayer->SelectionDelete();
	AddNewStep (IGFRAMEHISTORY_STEP_SELECTION, L"Change selection", (int)&selParams, (int)&lPts);
	Redraw (true);
	return bRes;
}
  queue_with_min(std::initializer_list<value_type> il)
      : data_(il)
     , min_( std::min_element(data_.cbegin(), data_.cend()) )
 {}
Exemple #30
0
std::wstring CRealTextParser::RenderTags(const std::list<Tag>& p_crlTags)
{
    bool bEmpty(true);
    std::wstring szString;

    for (auto iter = p_crlTags.cbegin(); iter != p_crlTags.cend(); ++iter) {
        Tag oTag(*iter);

        if (oTag.m_szName == L"br") {
            szString += L"\n";
        } else if (oTag.m_szName == L"b") {
            if (!m_bIgnoreFontWeight) {
                if (oTag.m_bOpen) {
                    szString += L"<b>";
                } else if (oTag.m_bClose) {
                    szString += L"</b>";
                }
            }
        } else if (oTag.m_szName == L"i") {
            if (!m_bIgnoreFontWeight) {
                if (oTag.m_bOpen) {
                    szString += L"<i>";
                } else if (oTag.m_bClose) {
                    szString += L"</i>";
                }
            }
        } else if (oTag.m_szName == L"font") {
            if (!m_bIgnoreFont) {
                if (oTag.m_bOpen) {
                    szString += L"<font";
                    for (std::map<std::wstring, std::wstring>:: iterator i = oTag.m_mapAttributes.begin(); i != oTag.m_mapAttributes.end(); ++i) {
                        if (m_bIgnoreFontSize && i->first == L"size") {
                            continue;
                        }

                        if (m_bIgnoreFontColor && i->first == L"color") {
                            continue;
                        }

                        if (m_bIgnoreFontFace && i->first == L"face") {
                            continue;
                        }

                        if (i->first == L"size" && !i->second.empty() && ::iswdigit(i->second.at(0))) {
                            int iSize = ::_wtoi(i->second.c_str());

                            if (iSize > 0 && iSize < m_iMinFontSize) {
                                continue;
                            }

                            if (iSize > m_iMaxFontSize) {
                                continue;
                            }
                        }

                        szString += L" ";
                        szString += i->first;
                        szString += L"=\"";
                        szString += i->second;
                        szString += L"\"";
                    }
                    szString += L">";
                }

                if (oTag.m_bClose) {
                    szString += L"</font>";
                }
            }
        } else if (oTag.m_bText) {
            szString += oTag.m_szName;

            if (!oTag.m_szName.empty()) {
                bEmpty = false;
            }
        } else {
            //AfxMessageBox(CString(_T("Unknown RealText-tag: ")) + oTag.m_szName.c_str());
        }
    }

    if (bEmpty) {
        return L"";
    } else {
        return szString;
    }
}