C++ AttributeMap::size方法代码示例

	void writeData(const QString& filename, const QString& defaultFilename,
		const AttributeMap& data, writeMode mode) throw(ParseError, Exception)
	{
		FNTRACE("ini", "", "writeData", QString("%1, %2, %3 rows of data, %4")
			.arg(filename).arg(defaultFilename).arg(data.size()).arg(mode));

		QFile file(filename);
		if (!file.exists())
			ETHROW(Exception(QString("File %1 does not exist.").arg(filename)));

		if (mode == preserve || mode == full)
		{
			QByteArray buf;
			QTextStream out(&buf);

			if (mode == full)
			{
				QFile defini(defaultFilename);
				writePreserving(defini, out, data);
			}
			else
			{
				writePreserving(file, out, data);
			}
			out.setDevice(0);

			if (file.isOpen()) file.close();
			if (!file.open(QIODevice::ReadWrite | QIODevice::Text | QIODevice::Truncate) ||
				!file.isWritable())
				ETHROW(Exception(QString("Unable to open %1 for writing.").arg(filename)));

			//file.resize(0);
			//if (!file.isOpen() || !file.isWritable())
			//	ETHROW(Exception(QString("%1 not writeable after resize.").arg(filename)));
			//file.close();
			/*if (!file.isOpen() || !file.isWritable())
				ETHROW(Exception(QString("%1 not writeable after closeing.").arg(filename)));*/
			//if (!file.open(QIODevice::ReadWrite | QIODevice::Text) || !file.isWritable())
			//	ETHROW(Exception(QString("Unable to open %1 for writing.").arg(filename)));
			/*file.seek(0);
			if (!file.isOpen() || !file.isWritable())
				ETHROW(Exception(QString("%1 not writeable after seek.").arg(filename)));*/
			out.setDevice(&file);
			if (!file.isOpen() || !file.isWritable())
				ETHROW(Exception(QString("%1 not writeable after stream-association.").arg(filename)));
			out << buf << flush;
		}
		else
			writeSparse(file, data);
	}

vector<AttributeMap> Ldap::search(string base, int scope, string filter, const StringList& attribs) {

    if(bound == false) {
        return vector<AttributeMap>();
    }

    LDAPSearchResults* lr = lc->search(base, scope, filter,attribs, false);

    LDAPEntry* le;
    const LDAPAttribute* la;
    StringList s;
    vector<AttributeMap> result;
	AttributeMap temp;
	int i = 0;

    while( (le = lr->getNext()) ) {

    	for(StringList::const_iterator
    			it =attribs.begin();
				it!=attribs.end();
				it++)
    	{
    	    //cout << endl << "Name: " << *it << " |";
    		la = le->getAttributeByName(*it);
    		if(la == NULL) continue;
			s = la->getValues();
			for(StringList::const_iterator
					st = s.begin();
					st != s.end();
					st ++)
			{
			    // concatenates multivalues with |
				temp[*it] += (i>0?"|"+*st:*st);
				i++;
			}
			i=0;
    	}
    	//cout << endl;

    	if(temp.size() > 0) {
			result.push_back(temp);
	    	temp.clear();
		}

    }

    return result;
}

	void readData(const QString& filename, AttributeMap& data) throw(ParseError, Exception)
	{
		FNTRACE("ini", "", "readData", QString("%1, %2 rows of data").arg(filename).arg(data.size()));

		QFile file(filename);
		if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
			ETHROW(Exception(QString("Unable to open %1 for reading.").arg(filename)));

		QByteArray line;
		size_t lineNumber = 0;

		while (!file.atEnd()) {

			line = file.readLine();
			++lineNumber;

			// trim comments and whitespace
			if (line.isEmpty()) continue;
			if (line.contains(COMMENT_BEGIN))
				line.truncate(line.indexOf(COMMENT_BEGIN));
			if (line.isEmpty()) continue;
			line = line.trimmed();
			if (line.isEmpty()) continue;

			// name=value pair?
			else if (line.contains(ASSIGNER))
			{
				QString name = line.left(line.indexOf(ASSIGNER));
				name = name.trimmed();
				if (name.isEmpty())
					ETHROW(ParseError(filename, lineNumber, "Empty name left of assigner."));
				QString value = line.right(line.length() - line.indexOf(ASSIGNER) - 1);
				value = value.trimmed();
				data[name] = value;
			}
			else
				ETHROW(ParseError(filename, lineNumber, "Unknown non-empty line."));
		}
	}

	void writePreserving(QFile& inFile, QTextStream& out, const AttributeMap& data)
	{
		FNTRACE("ini", "", "writePreserving", QString("in, out, %1 rows of data").arg(data.size()));

		int i, j;
		QChar c;
		QString name;
		size_t lineNumber = 0;
		QString line;
		typedef QSet<AttributeMap::key_type> KeySet;
		KeySet unwrittenKeys = KeySet::fromList(data.keys());

		if (!inFile.open(QIODevice::ReadOnly | QIODevice::Text))
			ETHROW(Exception(QString("Unable to open %1 for reading.").arg(inFile.fileName())));
		QTextStream in(&inFile);

		while (!(line = in.readLine()).isNull())
		{
			++lineNumber;
			//std::cout << lineNumber << ": " << line.toStdString() << ":\n";

			for (i = 0; line[i].isSpace(); ++i) { out << line[i]; }

			if (line[i].isNull()) { out << '\n'; continue; }
			else if (line[i] == COMMENT_BEGIN) { out << line.mid(i) << '\n'; continue; }

			for (j = i; !(c = line[i]).isNull() && c!=COMMENT_BEGIN && c!=ASSIGNER; ++i) ;
			//std::cout << "non-empty, ";
			if (c != ASSIGNER) // non-empty line that isn't assignment -> invalid
				ETHROW(ParseError(inFile.fileName(), lineNumber, "Unknown non-empty line."));
			for (--i; line[i].isSpace(); --i) ; // last character of name
			name = line.mid(j, i - j + 1);
			//std::cout << "name: " << name.toStdString() << ' ';

			for ( ; line[j]!=ASSIGNER; ++j) out << line[j];
			out << ASSIGNER;
			i = j + 1;

			for ( ; line[i].isSpace(); ++i) out << line[i];

			if (data.contains(name))
			{
				//std::cout << "known ";
				out << data.value(name);
				unwrittenKeys.remove(name);
				for (j = i; !line[i].isNull() && line[i]!=COMMENT_BEGIN; ++i) ; // EOL || comment
				for (--i; line[i].isSpace(); --i) ; // last character of value
				++i; // first character after value
			}

			out << line.mid(i) << '\n';
			//std::cout << '\n';
		}

		if (unwrittenKeys.size())
		{
			out << '\n' << COMMENT_BEGIN << "Following lines were generated by Ds1edit Loader:\n";
			for (KeySet::iterator key = unwrittenKeys.begin();
				key != unwrittenKeys.end(); ++key)
				out << (*key) << ' ' << ASSIGNER << ' ' << data.value(*key) << '\n';
		}

		//in.resize(in.pos()+1);
		inFile.close();
	}

	void writeSparse(QFile& file, const AttributeMap& data)
	{
		FNTRACE("ini", "", "writeSparse", QString("file %1, %2 rows of data").arg(file.fileName()).arg(data.size()));

		if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
			ETHROW(Exception(QString("Unable to open %1 for writing.").arg(file.fileName())));

		file.resize(0);
		QTextStream fout(&file);

		int max_key_length = 0;
		for (AttributeMap::const_iterator iter = data.begin(); iter != data.end(); ++iter)
		{
			if (iter.key().length() > max_key_length)
				max_key_length = iter.key().length();
		}
		for (AttributeMap::const_iterator iter = data.begin(); iter != data.end(); ++iter)
		{
			fout << iter.key();
			for (int i = iter.key().length(); i < max_key_length; ++i)
				fout << ' ';
			fout << " = " << iter.value() << "\n";
		}
	}

void ManufacturingSchematic::sendAttributes(PlayerObject* playerObject)
{

	if(playerObject->getConnectionState() != PlayerConnState_Connected)
		return;

	TangibleObject* tItem = this->getItem();
	if(!tItem)
		return;

	AttributeMap::iterator		mapIt;
	AttributeMap*				iAttributeMap		= tItem->getAttributeMap();
	AttributeOrderList*			iAttributeOrderList	= tItem->getAttributeOrder();

	AttributeMap*				rAttributeMap		= getAttributeMap();
	AttributeOrderList*			rAttributeOrderList	= getAttributeOrder();

	//DraftSchematic*				draftSchematic		= gSchematicManager->getSchematicBySlotId(mDynamicInt32);
	//DraftSlots*					draftSlots			= draftSchematic->getDraftSlots();

	Message*					newMessage;
	string						value,aStr;
	BStringVector				dataElements;

	//uint32	amountSlots		= draftSlots->size();
	//uint8	i				= 0;

	gMessageFactory->StartMessage();
	gMessageFactory->addUint32(opAttributeListMessage);
	gMessageFactory->addUint64(mId);

	//add slots and resource/item requirements

	gMessageFactory->addUint32(iAttributeMap->size()+ rAttributeMap->size()+1);

	AttributeOrderList::iterator	orderIt = rAttributeOrderList->begin();

	while(orderIt != rAttributeOrderList->end())
	{
		mapIt = rAttributeMap->find(*orderIt);

		gMessageFactory->addString(gWorldManager->getAttributeKey((*mapIt).first));

		value = (*mapIt).second.c_str();
		value.convert(BSTRType_Unicode16);

		gMessageFactory->addString(value);

		++orderIt;
	}

	//attributes ....
	gMessageFactory->addString(BString("manf_attribs"));
	aStr = "\\#"SOE_RED" --------------";
	aStr.convert(BSTRType_Unicode16);
	gMessageFactory->addString(aStr);


	orderIt = iAttributeOrderList->begin();

	while(orderIt != iAttributeOrderList->end())
	{
		mapIt = iAttributeMap->find(*orderIt);

		gMessageFactory->addString(gWorldManager->getAttributeKey((*mapIt).first));

		value = (*mapIt).second.c_str();
		value.convert(BSTRType_Unicode16);

		gMessageFactory->addString(value);

		++orderIt;
	}

	//gMessageFactory->addUint32(0xffffffff);

	newMessage = gMessageFactory->EndMessage();

	(playerObject->getClient())->SendChannelAUnreliable(newMessage, playerObject->getAccountId(),CR_Client,9);

}

void FactoryCrate::sendAttributes(PlayerObject* playerObject)
{

    if(!(playerObject->isConnected()))
        return;

    AttributeMap*				iAttributeMap		= this->getLinkedObject()->getAttributeMap();
    AttributeOrderList*			iAttributeOrderList	= this->getLinkedObject()->getAttributeOrder();

    Message* newMessage;

    gMessageFactory->StartMessage();
    gMessageFactory->addUint32(opAttributeListMessage);
    gMessageFactory->addUint64(mId);

    gMessageFactory->addUint32(2 + mAttributeMap.size()+iAttributeMap->size());

    BString	tmpValueStr = BString(BSTRType_Unicode16,64);
    BString	value,aStr;

    tmpValueStr.setLength(swprintf(tmpValueStr.getUnicode16(),50,L"%u/%u",mMaxCondition - mDamage,mMaxCondition));

    gMessageFactory->addString(BString("condition"));
    gMessageFactory->addString(tmpValueStr);

    AttributeMap::iterator			mapIt;
    AttributeOrderList::iterator	orderIt = mAttributeOrderList.begin();



    while(orderIt != mAttributeOrderList.end())
    {
        mapIt = mAttributeMap.find(*orderIt);

        gMessageFactory->addString(gWorldManager->getAttributeKey((*mapIt).first));

        value = (*mapIt).second.c_str();
        value.convert(BSTRType_Unicode16);

        gMessageFactory->addString(value);

        ++orderIt;
    }

    gMessageFactory->addString(BString("factory_attribs"));
    aStr = "\\#"SOE_RED" --------------";
    aStr.convert(BSTRType_Unicode16);
    gMessageFactory->addString(aStr);

    orderIt = iAttributeOrderList->begin();

    while(orderIt != iAttributeOrderList->end())
    {
        mapIt = iAttributeMap->find(*orderIt);

        gMessageFactory->addString(gWorldManager->getAttributeKey((*mapIt).first));

        value = (*mapIt).second.c_str();
        value.convert(BSTRType_Unicode16);

        gMessageFactory->addString(value);

        ++orderIt;
    }

    newMessage = gMessageFactory->EndMessage();

    (playerObject->getClient())->SendChannelAUnreliable(newMessage, playerObject->getAccountId(), CR_Client, 9);
}

bool MessageLib::sendBaselinesMSCO_3(ManufacturingSchematic* manSchem,PlayerObject* playerObject,bool sendAttributes)
{
	if(!(playerObject->isConnected()))
		return(false);

	Message*			message;
	Message*			part;
	DraftSchematic*		draftSchematic = gSchematicManager->getSchematicBySlotId(manSchem->getDynamicInt32());

	AttributeMap*			attributes		= manSchem->getAttributeMap();
	AttributeMap::iterator	it				= attributes->begin();
	uint32					attByteCount	= 0;

	if(sendAttributes)
	{
		while(it != attributes->end())
		{
			attByteCount += 21 + gWorldManager->getAttributeKey((*it).first).getLength();
			++it;
		}
	}

	if(!draftSchematic)
		return(false);

	string					convPlayerName	= playerObject->getFirstName();
	string					convCustomName	= manSchem->getCustomName();

	convPlayerName.convert(BSTRType_Unicode16);
	convCustomName.convert(BSTRType_Unicode16);

	mMessageFactory->StartMessage();

	//object count
	mMessageFactory->addUint16(13);

	//0
	mMessageFactory->addFloat(static_cast<float>(draftSchematic->getComplexity()));
	
	//1
	mMessageFactory->addString(manSchem->getNameFile());
	mMessageFactory->addUint32(0);
	mMessageFactory->addString(manSchem->getName());
	
	//2
	mMessageFactory->addString(convCustomName);
	
	//3 = volume
	mMessageFactory->addUint32(1);
	
	//4 = schematic quantity used with schematics with limited uses
	mMessageFactory->addUint32(1);

	//5
	// send attributes on baseline so that they are shown on assembly
	//cave review update counter
	if(sendAttributes)
	{
		manSchem->mAttributesUpdateCounter = attributes->size();
		mMessageFactory->addUint32(attributes->size());
		mMessageFactory->addUint32(manSchem->mAttributesUpdateCounter);

		it = attributes->begin();

		while(it != attributes->end())
		{
			mMessageFactory->addUint8(0);
			mMessageFactory->addString(BString("crafting"));
			mMessageFactory->addUint32(0);
			mMessageFactory->addString(gWorldManager->getAttributeKey((*it).first));

			//=============================0
			// see whether the attribute has any component values which need adding in the preview

			if(manSchem->hasPPAttribute(gWorldManager->getAttributeKey((*it).first)))
			{
				float attributeValue = boost::lexical_cast<float,std::string>((*it).second);
				float attributeAddValue = manSchem->getPPAttribute<float>(gWorldManager->getAttributeKey((*it).first));
				gLogger->logMsgF("MessageLib::sendBaselinesMSCO_3 Attribute Add Value",MSG_NORMAL);
				gLogger->logMsgF("MessageLib::sendBaselinesMSCO_3 we will add %f to %S",MSG_NORMAL,attributeAddValue,gWorldManager->getAttributeKey((*it).first).getAnsi());
				mMessageFactory->addFloat(attributeValue+attributeAddValue);
			}
			else
				mMessageFactory->addFloat(boost::lexical_cast<float,std::string>((*it).second));

			++it;
		}
	}
	else
	{
		mMessageFactory->addUint32(0);
		mMessageFactory->addUint32(0);
	}
	//6 creators name
	mMessageFactory->addString(convPlayerName);
	
	//7 complexity
	mMessageFactory->addUint32(static_cast<uint32>(manSchem->getComplexity()));
	
	// schematic data size
//.........这里部分代码省略.........