string JsonVehicleRecord::convertToJSON(const VehicleRecord &rVehicleRecord) {
	// String to represent the vehicle record object
	string json_obj_string;

	string json_license = convertString(rVehicleRecord.getLicensePlate());
	string json_type = convertString(rVehicleRecord.getVehicleType());
	string json_speed= convertFloat(rVehicleRecord.getSpeed());
	string json_date = convertDate(rVehicleRecord.getDate());

	//Adds the initial character of a json object
	json_obj_string += OBJ_START_CHAR;
	//Adds the license plate attribute
	json_obj_string += RECORD_LICEN_ATTR + ATTR_DECLA_CHAR + json_license;
	//Adds the separator character between attributes
	json_obj_string += ATTR_SEPAR_CHAR;
	//Adds the vehicle type attribute
	json_obj_string += RECORD_TYPE_ATTR + ATTR_DECLA_CHAR + json_type;
	//Adds the separator character between attributes
	json_obj_string += ATTR_SEPAR_CHAR;
	//Adds the speed attribute
	json_obj_string += RECORD_SPEED_ATTR + ATTR_DECLA_CHAR + json_speed;
	//Adds the separator character between attributes
	json_obj_string += ATTR_SEPAR_CHAR;
	//Adds the date attribute
	json_obj_string += RECORD_DATE_ATTR + ATTR_DECLA_CHAR + json_date;
	//Adds the end character of a json object
	json_obj_string += OBJ_END_CHAR;

	return json_obj_string;
}
Beispiel #2
0
void print_menuItems(char item1[], char item2[], char item3[], char item4[]){
	clear_pixelMatrix();
	int xPosItem = 20;
	int yPosItem = 3;
	
	//Item1
	int item1_ASCII [strlen(item1)];
	convertString(item1, item1_ASCII);
	print_ASCIIString(xPosItem, yPosItem, item1_ASCII, sizeof(item1_ASCII)/sizeof(item1_ASCII[0]));
	yPosItem += 15;

	//Item2
	int item2_ASCII [strlen(item2)];
	convertString(item2, item2_ASCII);
	print_ASCIIString(xPosItem, yPosItem, item2_ASCII, sizeof(item2_ASCII)/sizeof(item2_ASCII[0]));
	yPosItem += 15;

	//Item3
	int item3_ASCII [strlen(item3)];
	convertString(item3, item3_ASCII);
	print_ASCIIString(xPosItem, yPosItem, item3_ASCII, sizeof(item3_ASCII)/sizeof(item3_ASCII[0]));
	yPosItem += 15;

	//Item4
	int item4_ASCII [strlen(item4)];
	convertString(item4, item4_ASCII);
	print_ASCIIString(xPosItem, yPosItem, item4_ASCII, sizeof(item4_ASCII)/sizeof(item4_ASCII[0]));
	
	//Haken
	print_symbol(16,17, hakenSymb,108,46);
}
Beispiel #3
0
namespace LightSpeed {

defineTest test_textToBase64("baseX.textToBase64","UHJpc2VybmUgemx1dG91Y2t5IGt1biB1cGVsIGRhYmVsc2tlIGtvZHk=MTIzNA==",[](PrintTextA &out) {

	CharsToBytesConvert charToByte;
	ByteToBase64Convert base64conv;
	ConverterChain<CharsToBytesConvert &, ByteToBase64Convert &> convChain(charToByte, base64conv);

	ConstStrA text("Priserne zlutoucky kun upel dabelske kody");
	StringA conv = StringA(convertString(convChain, text));
	out("%1") << conv;

	base64conv.eolb = false;

	ConstStrA text2("1234");
	StringA conv2 = StringA(convertString(convChain, text2));
	out("%1") << conv2;
});

defineTest test_base64ToText("baseX.base64ToText","Priserne zlutoucky kun upel dabelske kody",[](PrintTextA &out){


	BytesToCharsConvert charToByte;
	Base64ToByteConvert base64conv;
	ConverterChain<Base64ToByteConvert &, BytesToCharsConvert &> convChain(base64conv,charToByte);

	ConstStrA text("UHJpc2VybmUgemx1dG91Y2t5IGt1biB1cGVsIGRhYmVsc2tlIGtvZHk=");
	StringA conv = StringA(convertString(convChain, text));
	out("%1") << conv;

});

}
Beispiel #4
0
void displayMenu(std::shared_ptr< Overlay::ISurface > pSurface) {
	pSurface->Rect(150, 50, 300, 170, createRGBA(101, 71, 39, 255));
	pSurface->BorderBox(150, 50, 300, 170, 3,createRGBA(10, 10, 10, 255));
	pSurface->String(165, 65, "Headline", createRGBA(255, 240, 190, 255), convertString("Percentual HP - F10"));
	pSurface->String(175, 105, "Default", createRGBA(255, 240, 190, 255), convertString(">Calibrate"));
	pSurface->String(175, 130, "Default", createRGBA(255, 240, 190, 255), convertString(">Set Position"));
	//pSurface->BorderBox(170, 100, 150, 25, 3, createRGBA(10, 10, 10, 255));
	pSurface->String(175, 180, "Default", createRGBA(255, 240, 190, 255), convertString(infoText));
	//pSurface->String(175, 250, "Default", createRGBA(255, 240, 190, 255), convertString(debugText));
}
Beispiel #5
0
/**
 * Export VirtualBox medium attachment
 */
static void exportVirtualBoxMediumAttachment(IMediumAttachment *mediumAttachment, xmlTextWriterPtr writer) {
	// find info
	string controller;
	PRInt32 port = 0;
	PRInt32 device = 0;
	PRUint32 type = 0;
	nsCOMPtr<IMedium> medium;

	{
		nsXPIDLString value;
		nsresult rc = mediumAttachment->GetController(getter_Copies(value));

		if (NS_SUCCEEDED(rc)) {
			controller = convertString(value);
		}
	}
	mediumAttachment->GetPort(&port);
	mediumAttachment->GetDevice(&device);
	mediumAttachment->GetType(&type);
	mediumAttachment->GetMedium(getter_AddRefs(medium));

	// slot description
	char name[1024];
	string location = "none";

	if (type == DeviceType_Floppy || type == DeviceType_DVD) {
		location = "emptydrive";
	}
	if (medium != nsnull) {
		nsXPIDLString value;
		nsresult rc = medium->GetLocation(getter_Copies(value));

		if (NS_SUCCEEDED(rc)) {
			location = convertString(value);
		}
	}

	sprintf(name, "%s-%ld-%ld", controller.c_str(), (long int)port, (long int)device);
	WRITEXMLSTRING(name, location);

	if (medium != nsnull) {
		nsXPIDLString value;
		nsresult rc = medium->GetId(getter_Copies(value));
		string uuid;

		if (NS_SUCCEEDED(rc)) {
			uuid = convertString(value);
		}

		sprintf(name, "%s-ImageUUID-%ld-%ld", controller.c_str(), (long int)port, (long int)device);
		WRITEXMLSTRING(name, uuid);
	}
}
Beispiel #6
0
/**
 * Export VirtualBox vrde server
 */
static void exportVirtualBoxVRDEServer(IVRDEServer *vrdeServer, xmlTextWriterPtr writer) {
	nsresult rc;

	// find info
	PRBool enabled = PR_FALSE;

	vrdeServer->GetEnabled(&enabled);

	// vrde enabled
	ADDXMLBOOL(vrdeServer->GetEnabled, "vrde");

	if (enabled == PR_TRUE) {
		// vrde extpack
		ADDXMLSTRING(vrdeServer->GetVRDEExtPack, "vrde.ext");

		// vrde auth lib
		ADDXMLSTRING(vrdeServer->GetAuthLibrary, "vrde.authlib");

		// vrde multicon
		ADDXMLBOOL(vrdeServer->GetAllowMultiConnection, "vrde.multicon");

		// vrde reusecon
		ADDXMLBOOL(vrdeServer->GetReuseSingleConnection, "vrde.reusecon");

		// vrde properties
		{
			PRUnichar **properties = nsnull;
			PRUint32 propertiesCount = 0;
			nsAutoString keyPrefix;

			rc = vrdeServer->GetVRDEProperties(&propertiesCount, &properties);
			if (NS_SUCCEEDED(rc)) {
				for (PRUint32 i = 0; i < propertiesCount; i++) {
					nsXPIDLString value;

					rc = vrdeServer->GetVRDEProperty(properties[i], getter_Copies(value));
					if (NS_SUCCEEDED(rc)) {
						nsCAutoString key("vrde.");

						key.AppendWithConversion(properties[i]);
						WRITEXMLSTRING(convertString(key).c_str(), convertString(value));
					}
				}

				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertiesCount, properties);
			}
		}
	}
}
Beispiel #7
0
double PCalc::calculateString(const QString &string)
{

	QString str = convertString(string);
	QStringList lst = str.split(" ");
	QStack<double> stack;

	for(int i = 0; i < lst.count(); i++)
	{
		bool ok = false;
		double d = lst[i].toDouble(&ok);
		if(ok)
			stack.push(d);
		else
		{
			double d1 = stack.pop();
			double d2 = stack.pop();

			if( lst[i] == "+" )
				stack.push(d2 + d1);
			else if( lst[i] == "-" )
				stack.push(d2 - d1);
			else if( lst[i] == "*" )
				stack.push(d2 * d1);
			else if( lst[i] == "/")
				stack.push(d2 / d1);
			else if( lst[i] == "^")
				stack.push( pow(d2, d1) );
		}
	}

	double a = stack.pop();
	return a;
}
Beispiel #8
0
//=============================================================================
CIFin::CifFile::CifFile(std::string filename)
{
   _first = _current = _default = NULL;
   _curLay = NULL;
   _hierTree = NULL;
   _fileName = filename;
   std::ostringstream info;
   // Open the input file
	std::string fname(convertString(_fileName));
   if (!(_cifFh = fopen(fname.c_str(),"rt"))) // open the input file
   {
      _status = cfs_FNF; return;
   }
   // feed the flex with the buffer of the input file
   void* b = new_cif_lex_buffer( _cifFh );
   info << "Parsing \"" << _fileName << "\" using CIF grammar";
   tell_log(console::MT_INFO,info.str());
   CIFInFile = this;
   _default = DEBUG_NEW CifStructure(0,NULL);
   _default->cellNameIs(std::string(getFileNameOnly(filename) + "_cif"));

   // run the bison generated parser
   ciflloc.first_column = ciflloc.first_line = 1;
   ciflloc.last_column  = ciflloc.last_line  = 1;
/*   cifdebug = 1;*/
   cifparse();
   delete_cif_lex_buffer( b );
   if (cifnerrs > 0) _status = cfs_ERR;
   else              _status = cfs_POK;
   closeFile();
}
Beispiel #9
0
void LogsProcessor::saveAll()
{
    for (int i=0,e=m_towrite.size(); i<e; ++i)
    {
        int id = m_towrite[i].log;
        if (id == -1)
            continue;
        CSectionLock _lock(m_cs_logs);
        int lastid = m_logs.size()-1;
        if (id < 0 || id > lastid || !m_logs[id])
            continue;
        prepare(id);

        for (int j=i; j<e; ++j)
        {
            msg &m = m_towrite[j];
            if (m.log != id) continue;                
            m.log = -1;
            std::string out;
            convertString(m.str, &out);
            write(m_logs[id]->hfile, out);
        }
    }
    
    CSectionLock _lock(m_cs);
    for (int i=0,e=m_towrite.size(); i<e; ++i)
    {
        MudViewString *s = m_towrite[i].str;
        m_free.push_back(s);
    }
    m_towrite.clear();    
}
Beispiel #10
0
size_t writeString(WriteStream &stream, const Common::UString &str, Encoding encoding, bool terminate) {
	ScopedPtr<MemoryReadStream> data(convertString(str, encoding, terminate));

	const size_t n = stream.writeStream(*data);

	return n;
}
Beispiel #11
0
	void print_date(int yPos) {
		for(int x = 0; x<128; x++) {
			for(int y=yPos; y<yPos+18; y++ ){
				reset_pixel(x,y);
			}
		}
		/*int dayWidth = get_dayWidth();
		int monthWidth = get_monthWidth();
		int dateWidth = dayWidth + monthWidth + 6; //6=Punkt + Leerzeichen
		int xPosDate = (127 - dateWidth) / 2 + 1;*/
		int xPosDate = get_dateXPos();
		
		if ((yPos == POS_DATE_STD) && (day==14) && (month==1)){
			uint8_t roseSymb[90];
			for(int i=0; i<90; i++){
				roseSymb[i] = pgm_read_byte(&rose[0][i]);
			}
			print_symbol(16, 45, roseSymb, (127 - ROSE_WIDTH) / 2 + 1, POS_DATE_STD);
		} else if ((yPos == POS_DATE_STD) && (day==4) && (month==7)) {
			int spruch [11];
			convertString("Alles Liebe", spruch);
			int xSpruch = (127 - get_stringWidth(spruch, 11)) / 2 + 1;
			print_ASCIIString(xSpruch, POS_DATE_STD, spruch, 11);
			uint8_t herzSymb[32];
			for(int i=0; i<32; i++){
				herzSymb[i] = pgm_read_byte(&herz[0][i]);
			}
			print_symbol(16, 16, herzSymb, xSpruch - 16 - 4, POS_DATE_STD);
			print_symbol(16, 16, herzSymb, xSpruch + get_stringWidth(spruch, 11) + 4, POS_DATE_STD);
		} else {
			print_day(xPosDate, yPos);	//Tag
			print_letter(alphaHeight, pgm_read_byte(&alphaWidth[54]), 54, xPosDate + get_dayWidth() + 1, yPos); //Punkt
			print_month(xPosDate + get_dayWidth() + 6, yPos); //Monat ..+6=Punkt+Leerzeichen
		}
	}
bool EffectShaderAnnotationDX9Imp::acquireResource()
{
    assert( effect_ );
    if( NULL == effect_ ) return false;

    switch( searchBy_ )
    {
    case ESEARCH_BY_INDEX:
        handle_ = effect_->GetAnnotation( getParentHandle(), index_ );
        break;
    case ESEARCH_BY_NAME:
        handle_ = effect_->GetParameterByName( getParentHandle(), convertString( name_ ).c_str() );
        break;
    }

    if( NULL == handle_ ) {
        wchar_t tmp[256];
        _snwprintf_s( tmp, 256, L"EffectShaderAnnotationDX9Imp::acquireResource\n" );
        OutputDebugStr( tmp );
        return false;
    }

    assert( effect_ );
    effect_->GetParameterDesc( getHandleDX9(), & desc_ );

    return true;
}
Beispiel #13
0
svd::svd(char* inPath, char* outPath,char* k)
{
	string command="redsvd -i ";
	command=command+inPath+" -o "+outPath+"/matrix -r "+k;
	char* comm=convertString(&command);
	system(comm);
	delete comm;
}
Beispiel #14
0
void writeStringFixed(WriteStream &stream, const Common::UString &str, Encoding encoding, size_t length) {
	if (length == 0)
		return;

	ScopedPtr<MemoryReadStream> data(convertString(str, encoding, false));

	size_t n = stream.writeStream(*data, length);
	while (n++ < length)
		stream.writeByte(0);
}
bool KSDBHandler::saveWord(const QString &word, const QString &text, bool add, const QString &id)
{
    QString rawQuery, search;
    search = convertString(word);
    if(add)
    {
        rawQuery="INSERT INTO phrases ( name , search , text ) VALUES ( '"+word+"' , '"+search+"' , \""+text+"\" );";
    }
    else
    {
        rawQuery="UPDATE phrases SET name='"+word+"', search='"+search+"' , text=\""+text+"\" WHERE id_phrase='"+id+"';";
    }
    return query(rawQuery);
}
/* void OnStopSending (in string aMsgID, in nsresult aStatus, in wstring aMsg, in nsIFile returnFile); */
NS_IMETHODIMP MailEwsSendListener::OnStopSending(const char *aMsgID,
                                                 nsresult aStatus,
                                                 const char16_t *aMsg,
                                                 nsIFile *returnFile) {
    IMPORT_LOG0("Send end!");
    m_done = true;
    m_location = returnFile;
    nsString path;
    returnFile->GetPath(path);
    NS_LossyConvertUTF16toASCII_external convertString(path);

    mailews_logger << "msg file:"
              << convertString.get()
              << std::endl;
    return NS_OK;
}
Beispiel #17
0
void writeStringFixed(WriteStream &stream, const Common::UString &str, Encoding encoding, size_t length) {
	MemoryReadStream *data = 0;
	try {
		data = convertString(str, encoding, false);

		size_t n = stream.writeStream(*data, length);
		while (n++ < length)
			stream.writeByte(0);

	} catch (...) {
		delete data;
		throw;
	}

	delete data;
}
Beispiel #18
0
void TSocket::execQuery( const QString &str )
{
        QString error = "";
        QString data;

        QSqlDatabase db = QSqlDatabase::database();
        if( !db.isValid() )
                error = tr("Connection to the database is not established!");

        if( error.isEmpty() || error.isNull() )
        {
                //опасное место. исправить.
                QSqlQuery query( convertString(str) );

                if( !query.isActive() )
                        error = query.lastError().text();

                QSqlRecord rec = query.record();
                if( rec.count() > 0 )
                {
                        data = "";
                        while( query.next() )
                        {            
                                int count = rec.count();
                                for(int i = 0; i < count; i++)
                                {
                                        data += query.value(i).toString().simplified();
                                        if( i != count-1 )
                                            data += "\t";
                                }
                                data += "\n";
                        }
                }

                QStringList list = data.split("\n");
                qDebug() << "Row count: " << list.count();
                qDebug() << data << "\n";
                for(int i = 0; i < list.count(); i++)
                    sendString( list[i] );
        }

        if( !error.isEmpty() && !error.isNull() )
        {
            writeData( error.toLocal8Bit().data(), qstrlen( error.toLocal8Bit().data() ) );
            return;
        }
}
Beispiel #19
0
size_t writeString(WriteStream &stream, const Common::UString &str, Encoding encoding, bool terminate) {
	size_t n = 0;

	MemoryReadStream *data = 0;
	try {
		data = convertString(str, encoding, terminate);

		n = stream.writeStream(*data);
	} catch (...) {
		delete data;
		throw;
	}

	delete data;

	return n;
}
Beispiel #20
0
//=============================================================================
CIFin::CifExportFile::CifExportFile(std::string fn, USMap* laymap, bool verbose)
{
   _fileName = fn;
   _laymap = laymap;
   _verbose = verbose;
   _lastcellnum = 0;
   std::string fname(convertString(_fileName));
   _file.open(_fileName.c_str(), std::ios::out);
   //@TODO how to check for an error ?
   // start writing
   TpdTime timec(time(NULL));

   _file << "(              CIF   2.0       );"    << std::endl;
   _file << "(        generator : Toped 0.9.x );"  << std::endl;
   _file << "(             user : tbd );"          << std::endl;
   _file << "(          machine : tbd );"          << std::endl;
   _file << "(       time stamp : " << timec() << ");" << std::endl;

}
Beispiel #21
0
void layprop::ViewProperties::saveProperties(std::string filename) const
{
   FILE * prop_file;
   std::string fname = convertString(filename);
   prop_file = fopen(fname.c_str(),"wt");
   // file header here
   _drawprop.savePatterns(prop_file);
   _drawprop.saveColors(prop_file);
   _drawprop.saveLines(prop_file);
   _drawprop.saveLayers(prop_file);
   if ((NULL != _gdsLayMap) || (NULL != _cifLayMap))
      saveLayerMaps(prop_file);
   saveScreenProps(prop_file);
   fprintf(prop_file, "layerSetup();");
   if ((NULL != _gdsLayMap) || (NULL != _cifLayMap))
      fprintf(prop_file, "layerMaps();");
   fprintf(prop_file, "screenSetup();\n\n");
   fclose(prop_file);
}
Beispiel #22
0
Common::String ResourceManager::getNumberedString(int value) {
	if (_sliceBusy) {
		fatal("Can't read from data file", "I'm already reading something");
		return NULL;
	}

	_bigDataFile->seek((value << 2) + _startOfTextIndex, 0);
	value = _bigDataFile->readUint32LE();
	_bigDataFile->seek(value, 0);

	Common::String s = readString(_bigDataFile);

	if (gameVersion < VERSION(2, 2)) {
		// This is an older game - We need to convert the string to UTF-8
		s = convertString(s);
	}

	return s;
}
Beispiel #23
0
void VariantToBsonConverter::convertElement(bson_t *bson, const char *key, Variant v)
{
	switch (v.getType()) {
		case KindOfUninit:
		case KindOfNull:
			convertNull(bson, key);
			break;
		case KindOfBoolean:
			convertBoolean(bson, key, v.toBoolean());
			break;
		case KindOfInt64:
			convertInt64(bson, key, v.toInt64());
			break;
		case KindOfDouble:
			convertDouble(bson, key, v.toDouble());
			break;
#if HIPPO_HHVM_VERSION >= 31200
		case KindOfPersistentString:
#else
		case KindOfStaticString:
#endif
		case KindOfString:
			convertString(bson, key, v.toString());
			break;
		case KindOfArray:
#if HIPPO_HHVM_VERSION >= 31100
		case KindOfPersistentArray:
#endif
		case KindOfObject:
			convertDocument(bson, key, v);
			break;
		case KindOfRef:
			convertElement(bson, key, *v.getRefData());
			break;
		case KindOfResource:
			throw MongoDriver::Utils::throwUnexpectedValueException("Got unsupported type 'resource'");
			return;
		case KindOfClass:
			not_reached();
	}
}
Beispiel #24
0
// .--- openFile() ---.
std::FILE *Platform::openFile(const UString &fileName, FileMode mode) {
	assert(((uint) mode) < kFileModeMAX);

	std::FILE *file = 0;

#if defined(WIN32)
	static const wchar_t *modeStrings[kFileModeMAX] = { L"rb", L"wb" };

	MemoryReadStream *utf16Name = convertString(fileName, kEncodingUTF16LE);

	file = _wfopen((const wchar_t *) utf16Name->getData(), modeStrings[(uint) mode]);

	delete utf16Name;
#else
	static const char *modeStrings[kFileModeMAX] = { "rb", "wb" };

	file = std::fopen(fileName.c_str(), modeStrings[(uint) mode]);
#endif

	return file;
}
void ParamConverter::editConvert()
{
    QString editContent = mainEdit->toPlainText();

    QStringList contentList = editContent.split('\n');
    int stringCount = contentList.size();

    QString tempString;
    QStringList convertedList;
    for(int i = 0;i < stringCount; i++)
    {
        tempString = contentList.at(i);
        if(tempString.length() == 0)
        {
            continue;
        }
        tempString = convertString(tempString);
        convertedList.push_back(tempString);
    }
    tempString = convertedList.join(' ');
    mainEdit->setPlainText(tempString);
}
Beispiel #26
0
int scan(char *filename) {
        yyin  = fopen(filename,"r");
	if (!yyin) {
		fprintf(stderr,"scan error: unable to open %s\n",filename);
		exit(1);
	}
        while(yyin) {
        	int t = yylex();
                if (!t)
                        break;
                printf("%s", token_string(t));
                if ( t == TOKEN_STRING_LITERAL || t == TOKEN_CHAR_LITERAL) {
                        char string[600];
                        strcpy(string,yytext);
                        convertString(string);
                        printf(" %s", string);
                }
                printf("\n");
        }
        fclose(yyin);
	return 0;
}
//-----------------------------------------------------------------------------
Calbr::CalbrFile::CalbrFile(const std::string &fileName)
		:_ok(true)
{
	std::ostringstream ost;
	_fileName = fileName;
	std::string fname(convertString(_fileName));
	if (!(_calbrFile = fopen(fname.c_str(),"rt"))) // open the input file
   {
		_ok = false;
		ost << "Can't open file " << fname;
		tell_log(console::MT_ERROR,ost.str());
		return;
   }

	//read header
	char str[512];
	if (fgets(str, 512, _calbrFile)==NULL) 
	{
		_ok = false;
		ost << "Problem of reading file " << fname;
		tell_log(console::MT_ERROR,ost.str());
		return;
	}

	
	char cellName[512];
	sscanf( str, "%s %ud", cellName, &_precision);
	//initialisation of static member drcPolygon class
	drcPolygon::_precision = _precision;
	drcEdge::_precision = _precision;
	_cellName = cellName;
	while(parse())
	{

	}
	
}
String
OSXClipboardTextConverter::doToIClipboard(const String& data) const
{
	return convertString(data, CFStringGetSystemEncoding(),
							kCFStringEncodingUTF8);
}
Beispiel #29
0
/**
 * Export VirtualBox machine
 */
void exportVirtualBoxMachine(IVirtualBox *virtualBox, IMachine *machine, xmlTextWriterPtr writer) {
	nsCOMPtr<ISystemProperties> systemProperties;
	nsresult rc = virtualBox->GetSystemProperties(getter_AddRefs(systemProperties));

	if (NS_SUCCEEDED(rc)) {
		xmlTextWriterStartElement(writer, TOXMLCHAR("machine"));

			// uuid
			ADDXMLSTRING(machine->GetId, "id");

			// name
			ADDXMLSTRING(machine->GetName, "name");

			// description
			ADDXMLSTRING(machine->GetDescription, "description");

			// os type
			ADDXMLSTRING(machine->GetOSTypeId, "ostype");

			// settings file
			ADDXMLSTRING(machine->GetSettingsFilePath, "path");

			// hardware uuid
			ADDXMLSTRING(machine->GetHardwareUUID, "hardwareuuid");

			// memory size
			ADDXMLINT32U(machine->GetMemorySize, "memory");

			// memory balloon size
			ADDXMLINT32U(machine->GetMemoryBalloonSize, "memoryballoon");

			// page fusion
			ADDXMLBOOL(machine->GetPageFusionEnabled, "pagefusion");

			// vram size
			ADDXMLINT32U(machine->GetVRAMSize, "vram");

			// hpet
			ADDXMLBOOL(machine->GetHPETEnabled, "hpet");

			// cpu count
			ADDXMLINT32U(machine->GetCPUCount, "cpus");

			// cpu execution cap
			ADDXMLINT32U(machine->GetCPUExecutionCap, "cpucap");

			// cpu hotplug
			ADDXMLBOOL(machine->GetCPUHotPlugEnabled, "cpuhotplug");

			// synthcpu
			// {
			// 	PRBool value;

			// 	rc = machine->GetCPUProperty(CPUPropertyType_Synthetic, &value);
			// 	if (NS_SUCCEEDED(rc)) {
			// 		WRITEXMLBOOL("synthcpu", value);
			// 	}
			// }

			// firmware type
			ADDXMLENUM(machine->GetFirmwareType, "firmware", firmwareTypeConverter);

			// bios settings
			{
				nsCOMPtr<IBIOSSettings> value;

				rc = machine->GetBIOSSettings(getter_AddRefs(value));
				if (NS_SUCCEEDED(rc)) {
					exportVirtualBoxBIOSSettings(value, writer);
				}
			}

			// boot order
			{
				PRUint32 bootPositions;

				rc = systemProperties->GetMaxBootPosition(&bootPositions);
				if (NS_SUCCEEDED(rc)) {
					for (PRUint32 i = 1; i <= bootPositions; i++) {
						PRUint32 value;

						rc = machine->GetBootOrder(i, &value);
						if (NS_SUCCEEDED(rc)) {
							char name[256];

							sprintf(name, "boot%d", i);
							WRITEXMLENUM(name, value, deviceTypeConverter);
						}
					}
				}
			}

			// pae
			{
				PRBool value;

				rc = machine->GetCPUProperty(CPUPropertyType_PAE, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("pae", value);
				}
			}

			// rtc use utc
			ADDXMLBOOL(machine->GetRTCUseUTC, "rtcuseutc");

			// monitor count
			ADDXMLINT32U(machine->GetMonitorCount, "monitorcount");

			// accelerate 3D
			ADDXMLBOOL(machine->GetAccelerate3DEnabled, "accelerate3d");

			// accelerate 2D video
			ADDXMLBOOL(machine->GetAccelerate2DVideoEnabled, "accelerate2dvideo");

			// hwvirtex
			{
				PRBool value;

				rc = machine->GetCPUProperty(HWVirtExPropertyType_Enabled, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("hwvirtex", value);
				}
			}

			// vtxvpid
			{
				PRBool value;

				rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("vtxvpid", value);
				}
			}

			// nestedpaging
			{
				PRBool value;

				rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("nestedpaging", value);
				}
			}

			// unrestrictedexec
			{
				PRBool value;

				rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("unrestrictedexec", value);
				}
			}

			// largepages
			{
				PRBool value;

				rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("largepages", value);
				}
			}

			// force
			{
				PRBool value;

				rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_Force, &value);
				if (NS_SUCCEEDED(rc)) {
					WRITEXMLBOOL("hwforce", value);
				}
			}

			// io cache
			ADDXMLBOOL(machine->GetIOCacheEnabled, "iocache");

			// io cache size
			ADDXMLINT32U(machine->GetIOCacheSize, "iocachesize");

			// chipset type
			ADDXMLENUM(machine->GetChipsetType, "chipset", chipsetTypeConverter);

			// pointing hid type
			ADDXMLENUM(machine->GetPointingHIDType, "mouse", pointingHidTypeConverter);

			// keyboard hid type
			ADDXMLENUM(machine->GetKeyboardHIDType, "keyboard", keyboardHidTypeConverter);

			// clipboard mode
			ADDXMLENUM(machine->GetClipboardMode, "clipboard", clipboardModeConverter);

			// vm state
			ADDXMLENUM(machine->GetState, "state", stateConverter);

			// vm state change
			ADDXMLTIMESTAMP(machine->GetLastStateChange, "statechanged");

			// teleporterenabled, teleporterport, teleporteraddress, teleporterpassword

			// storage controller
			{
				IStorageController **storageControllers = nsnull;
				PRUint32 storageControllersCount = 0;

				rc = machine->GetStorageControllers(&storageControllersCount, &storageControllers);
				if (NS_SUCCEEDED(rc)) {
					for (PRUint32 i = 0; i < storageControllersCount; i++) {
						exportVirtualBoxStorageController(storageControllers[i], i, writer);
					}
				}

				NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(storageControllersCount, storageControllers);
			}

			// medium attachments
			{
				IMediumAttachment **mediumAttachments = nsnull;
				PRUint32 mediumAttachmentsCount = 0;

				rc = machine->GetMediumAttachments(&mediumAttachmentsCount, &mediumAttachments);
				if (NS_SUCCEEDED(rc)) {
					for (PRUint32 i = 0; i < mediumAttachmentsCount; i++) {
						exportVirtualBoxMediumAttachment(mediumAttachments[i], writer);
					}
				}

				NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(mediumAttachmentsCount, mediumAttachments);
			}

			// network adapters
			{
				PRUint32 networkAdaptersCount;
				PRUint32 chipsetType;

				rc = machine->GetChipsetType(&chipsetType);
				if (NS_SUCCEEDED(rc)) {
					rc = systemProperties->GetMaxNetworkAdapters(chipsetType, &networkAdaptersCount);
					if (NS_SUCCEEDED(rc)) {
						for (PRUint32 i = 0; i < networkAdaptersCount; i++) {
							nsCOMPtr<INetworkAdapter> networkAdapter;

							rc = machine->GetNetworkAdapter(i, getter_AddRefs(networkAdapter));
							if (NS_SUCCEEDED(rc)) {
								exportVirtualBoxNetworkAdapter(networkAdapter, i + 1, writer);
							}
						}
					}
				}
			}

			// uartX

			// audio adapter
			{
				nsCOMPtr<IAudioAdapter> value;

				rc = machine->GetAudioAdapter(getter_AddRefs(value));
				if (NS_SUCCEEDED(rc)) {
					exportVirtualBoxAudioAdapter(value, writer);
				}
			}

			// vrde server
			{
				nsCOMPtr<IVRDEServer> value;

				rc = machine->GetVRDEServer(getter_AddRefs(value));
				if (NS_SUCCEEDED(rc)) {
					exportVirtualBoxVRDEServer(value, writer);
				}
			}

			// usb controllers
			// {
			// 	nsCOMPtr<IUSBController> value;

			// 	rc = machine->GetUSBController(getter_AddRefs(value));
			// 	if (NS_SUCCEEDED(rc)) {
			// 		exportVirtualBoxUSBController(value, writer);
			// 	}
			// }

			// guest properties
			{
				PRUnichar **names = nsnull;
				PRUnichar **values = nsnull;
				PRInt64 *timestamps = nsnull;
				PRUnichar **flags = nsnull;
				PRUint32 namesCount = 0;
				PRUint32 valuesCount = 0;
				PRUint32 timestampsCount = 0;
				PRUint32 flagsCount = 0;

				rc = machine->EnumerateGuestProperties((const PRUnichar*)nsnull, &namesCount, &names, &valuesCount, &values, &timestampsCount, &timestamps, &flagsCount, &flags);
				if (NS_SUCCEEDED(rc)) {
					for (PRUint32 i = 0; i < namesCount; i++) {
						nsAutoString name(names[i]);
						nsAutoString value(values[i]);
						PRUint64 timestamp = timestamps[i];
						nsAutoString flag(flags[i]);

						WRITEXMLSTRING(convertString(name).c_str(), convertString(value));
					}
				}

				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(namesCount, names);
				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(valuesCount, values);
				nsMemory::Free(timestamps);
				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(flagsCount, flags);
			}

		xmlTextWriterEndElement(writer);
	}
}
Beispiel #30
0
/**
 * Export VirtualBox network adapter
 */
static void exportVirtualBoxNetworkAdapter(INetworkAdapter *networkAdapter, PRUint32 index, xmlTextWriterPtr writer) {
	char name[256];
	nsresult rc;

	// find info
	PRUint32 attachmentType = 0;

	networkAdapter->GetAttachmentType(&attachmentType);

	// attachment type
	sprintf(name, "nic%d", index);
	ADDXMLENUM(networkAdapter->GetAttachmentType, name, networkAttachmentTypeConverter);

	// specific configuration
	switch (attachmentType) {
	case NetworkAttachmentType_NAT:
		// nat network
		sprintf(name, "natnet%d", index);
		ADDXMLSTRING(networkAdapter->GetNATNetwork, name);
		break;

	case NetworkAttachmentType_Bridged:
		// bridge adapter
		sprintf(name, "bridgeadapter%d", index);
		ADDXMLSTRING(networkAdapter->GetBridgedInterface, name);
		break;

	case NetworkAttachmentType_Internal:
		// internal network
		sprintf(name, "intnet%d", index);
		ADDXMLSTRING(networkAdapter->GetInternalNetwork, name);
		break;

	case NetworkAttachmentType_HostOnly:
		// host adapter
		sprintf(name, "hostonlyadapter%d", index);
		ADDXMLSTRING(networkAdapter->GetHostOnlyInterface, name);
		break;

	case NetworkAttachmentType_Generic:
		// generic adapter
		sprintf(name, "genericadapter%d", index);
		ADDXMLSTRING(networkAdapter->GetGenericDriver, name);
		break;
	}

	switch (attachmentType) {
	case NetworkAttachmentType_NAT:
	case NetworkAttachmentType_Bridged:
	case NetworkAttachmentType_Internal:
	case NetworkAttachmentType_HostOnly:
	case NetworkAttachmentType_Generic:
		// enabled
		sprintf(name, "nicenabled%d", index);
		ADDXMLBOOL(networkAdapter->GetEnabled, name);

		// enabled
		sprintf(name, "nicpriority%d", index);
		ADDXMLINT32U(networkAdapter->GetBootPriority, name);

		// adapter type
		sprintf(name, "nictype%d", index);
		ADDXMLENUM(networkAdapter->GetAdapterType, name, networkAdapterTypeConverter);

		// mac address
		sprintf(name, "macaddress%d", index);
		ADDXMLSTRING(networkAdapter->GetMACAddress, name);

		// cable connected
		sprintf(name, "cableconnected%d", index);
		ADDXMLBOOL(networkAdapter->GetCableConnected, name);

		// speed
		sprintf(name, "nicspeed%d", index);
		ADDXMLINT32U(networkAdapter->GetLineSpeed, name);
		break;

		// promisc policy
		sprintf(name, "nicpromisc%d", index);
		ADDXMLENUM(networkAdapter->GetPromiscModePolicy, name, promiscModePolicyConverter);

		// extra properties
		{
			PRUnichar **propertyNames = nsnull;
			PRUnichar **propertyValues = nsnull;
			PRUint32 propertyNamesCount = 0;
			PRUint32 propertyValuesCount = 0;

			sprintf(name, "nic%d_", index);

			rc = networkAdapter->GetProperties(NS_LITERAL_STRING("").get(), &propertyNamesCount, &propertyNames, &propertyValuesCount, &propertyValues);
			if (NS_SUCCEEDED(rc)) {
				for (PRUint32 i = 0; i < propertyNamesCount && i < propertyValuesCount; i++) {
					nsCAutoString key(name);
					nsString value(propertyValues[i]);

					key.AppendWithConversion(propertyNames[i]);
					WRITEXMLSTRING(convertString(key).c_str(), convertString(value));
				}

				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertyNamesCount, propertyNames);
				NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertyValuesCount, propertyValues);
			}
		}
	}
}