void addPropertyFunctions(QString &out, const QString &type,
const QString &name)
{
// FIXME: Use KODE::Function
bool isReference = type.endsWith("*") || type.endsWith("&");
QString argument;
QString upper = KODE::Style::upperFirst(name);
if(!isReference)
{
argument = "const " + type + " &";
}
else argument = type;
KODE::Code code;
code.setIndent(4);
code += "/**";
code += " Set .";
code += "*/";
code += "void set" + upper + "( " + argument + "v )";
code += "{";
code += " m" + upper + " = v;";
code += "}";
code += "/**";
code += " Get " + name + ". See set" + upper + "().";
code += "*/";
code += type + (isReference ? "" : " ") + name + "() const";
code += "{";
code += " return m" + upper + ";";
code += "}";
out += code.text();
}
void addPropertyVariable(QString &out, const QString &type,
const QString &name)
{
QString upper = KODE::Style::upperFirst(name);
bool isReference = type.endsWith("*") || type.endsWith("&");
KODE::Code code;
code.setIndent(4);
code += type + (isReference ? "" : " ") + "m" + upper + ";";
out += code.text();
}
void Converter::convertInputMessage( const Port &port, const Message &message, KODE::Class &newClass )
{
KODE::MemberVariable transport( message.name() + "Transport", "Transport*" );
newClass.addMemberVariable( transport );
// call
QString messageName = message.name();
messageName[ 0 ] = messageName[ 0 ].lower();
KODE::Function callFunc( mNameMapper.escape( messageName ), "void", KODE::Function::Public );
const Message::Part::List parts = message.parts();
Message::Part::List::ConstIterator it;
for ( it = parts.begin(); it != parts.end(); ++it ) {
newClass.addHeaderIncludes( mTypeMapper.header( (*it).type() ) );
QString lowerName = (*it).name();
lowerName[ 0 ] = lowerName[ 0 ].lower();
callFunc.addArgument( mTypeMapper.argument( mNameMapper.escape( lowerName ), (*it).type() ) );
}
KODE::Code code;
code += "QDomDocument doc( \"kwsdl\" );";
code += "doc.appendChild( doc.createProcessingInstruction( \"xml\", \"version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"\" ) );";
code += "QDomElement env = doc.createElement( \"SOAP-ENV:Envelope\" );";
code += "env.setAttribute( \"xmlns:SOAP-ENV\", \"http://schemas.xmlsoap.org/soap/envelope/\" );";
code += "env.setAttribute( \"xmlns:xsi\", \"http://www.w3.org/1999/XMLSchema-instance\" );";
code += "env.setAttribute( \"xmlns:xsd\", \"http://www.w3.org/1999/XMLSchema\" );";
code += "doc.appendChild( env );";
code += "QDomElement body = doc.createElement( \"SOAP-ENV:Body\" );";
code += "env.appendChild( body );";
code += "QDomElement method = doc.createElement( \"ns1:" + message.name() + "\" );";
QString nameSpace = mWSDL.findBindingOperation( port.name(), message.name() ).input().nameSpace();
code += "method.setAttribute( \"xmlns:ns1\", \"" + nameSpace + "\" );";
code += "method.setAttribute( \"SOAP-ENV:encodingStyle\", \"http://schemas.xmlsoap.org/soap/encoding/\" );";
code += "body.appendChild( method );";
code.newLine();
for ( it = parts.begin(); it != parts.end(); ++it ) {
QString lowerName = (*it).name();
lowerName[ 0 ] = lowerName[ 0 ].lower();
code += "Serializer::marshal( doc, method, \"" + (*it).name() + "\", " + mNameMapper.escape( lowerName ) + " );";
code += "delete " + mNameMapper.escape( lowerName ) + ";";
}
code += "qDebug( \"%s\", doc.toString().latin1() );";
code += transport.name() + "->query( doc.toString() );";
callFunc.setBody( code );
newClass.addFunction( callFunc );
}
void Converter::convertOutputMessage( const Port&, const Message &message, KODE::Class &newClass )
{
Message::Part part = message.parts().first();
// signal
QString messageName = message.name();
messageName[ 0 ] = messageName[ 0 ].lower();
KODE::Function respSignal( messageName, "void", KODE::Function::Signal );
/**
If one output message is used by two input messages, don't define
it twice.
*/
if ( newClass.hasFunction( respSignal.name() ) )
return;
const Message::Part::List parts = message.parts();
Message::Part::List::ConstIterator it;
for ( it = parts.begin(); it != parts.end(); ++it ) {
QStringList headers = mTypeMapper.header( (*it).type() );
for ( uint i = 0; i < headers.count(); ++i )
if ( !headers[ i ].isEmpty() )
newClass.addHeaderInclude( headers[ i ] );
respSignal.addArgument( mTypeMapper.argument( "value", (*it).type() ) );
}
newClass.addFunction( respSignal );
// slot
KODE::Function respSlot( messageName + "Slot", "void", KODE::Function::Slot | KODE::Function::Private );
respSlot.addArgument( "const QString &xml" );
KODE::Code code;
code += "QDomDocument doc;";
code += "QString errorMsg;";
code += "int column, row;";
code.newLine();
code += "qDebug( \"%s\", xml.latin1() );";
code.newLine();
code += "if ( !doc.setContent( xml, true, &errorMsg, &row, &column ) ) {";
code.indent();
code += "qDebug( \"Unable to parse xml: %s (%d:%d)\", errorMsg.latin1(), row, column );";
code += "return;";
code.unindent();
code += "}";
code.newLine();
code += mTypeMapper.type( part.type() ) + "* value = new " + mTypeMapper.type( part.type() ) + ";";
code += "QDomElement envelope = doc.documentElement();";
code += "QDomElement body = envelope.firstChild().toElement();";
code += "QDomElement method = body.firstChild().toElement();";
code += "Serializer::demarshal( method.firstChild().toElement(), value );";
code.newLine();
code += "emit " + respSignal.name() + "( value );";
respSlot.setBody( code );
newClass.addFunction( respSlot );
}
static KODE::Code createRangeCheckCode( const XSD::SimpleType *type, const QString &variableName, KODE::Class &parentClass )
{
KODE::Code code;
code += "bool rangeOk = true;";
code.newLine();
// TODO
/*
WhiteSpaceType facetWhiteSpace() const;
int facetTotalDigits() const;
int facetFractionDigits() const;
*/
if ( type->facetType() & XSD::SimpleType::MININC )
code += "rangeOk = rangeOk && (" + variableName + " >= " + QString::number( type->facetMinimumInclusive() ) + ");";
if ( type->facetType() & XSD::SimpleType::MINEX )
code += "rangeOk = rangeOk && (" + variableName + " > " + QString::number( type->facetMinimumExclusive() ) + ");";
if ( type->facetType() & XSD::SimpleType::MAXINC )
code += "rangeOk = rangeOk && (" + variableName + " <= " + QString::number( type->facetMaximumInclusive() ) + ");";
if ( type->facetType() & XSD::SimpleType::MINEX )
code += "rangeOk = rangeOk && (" + variableName + " < " + QString::number( type->facetMaximumExclusive() ) + ");";
if ( type->facetType() & XSD::SimpleType::LENGTH )
code += "rangeOk = rangeOk && (" + variableName + ".length() == " + QString::number( type->facetLength() ) + ");";
if ( type->facetType() & XSD::SimpleType::MINLEN )
code += "rangeOk = rangeOk && (" + variableName + ".length() >= " + QString::number( type->facetMinimumLength() ) + ");";
if ( type->facetType() & XSD::SimpleType::MAXLEN )
code += "rangeOk = rangeOk && (" + variableName + ".length() <= " + QString::number( type->facetMaximumLength() ) + ");";
if ( type->facetType() & XSD::SimpleType::PATTERN ) {
code += "QRegExp exp( \"" + type->facetPattern() + "\" );";
code += "rangeOk = rangeOk && exp.exactMatch( " + variableName + " );";
parentClass.addInclude( "QRegExp" );
}
return code;
}
void Converter::generateServerMethod(KODE::Code &code, const Binding &binding, const Operation &operation, KODE::Class &newClass, bool first)
{
const QString requestVarName = "_request";
const QString responseVarName = "_response";
const Message message = mWSDL.findMessage(operation.input().message());
Message outputMessage;
if (operation.operationType() != Operation::OneWayOperation) {
outputMessage = mWSDL.findMessage(operation.output().message());
}
const QString operationName = operation.name();
const QString methodName = mNameMapper.escape(lowerlize(operationName));
KODE::Function virtualMethod(methodName);
virtualMethod.setVirtualMode(KODE::Function::PureVirtual);
QString condition = "method == \"" + operationName + "\"";
if (binding.type() == Binding::SOAPBinding) {
const SoapBinding soapBinding(binding.soapBinding());
const SoapBinding::Operation op = soapBinding.operations().value(operation.name());
if (!op.action().isEmpty()) {
condition += " || _soapAction == \"" + op.action() + "\"";
}
}
code += QString(first ? "" : "else ") + "if (" + condition + ") {";
code.indent();
QStringList inputVars;
const Part::List parts = message.parts();
for (int partNum = 0; partNum < parts.count(); ++partNum) {
const Part part = parts.at(partNum);
const QString lowerName = lowerlize(part.name());
const QString argType = mTypeMap.localType(part.type(), part.element());
//qDebug() << "localInputType" << part.type().qname() << part.element().qname() << "->" << argType;
if (argType != "void") {
const QString varName = mNameMapper.escape(lowerName);
code += argType + ' ' + varName + ";" + COMMENT;
QString soapValueVarName = requestVarName;
if (soapStyle(binding) == SoapBinding::RPCStyle) {
// RPC comes with a wrapper element, dig into it here
soapValueVarName = "val";
if (partNum > 0) {
soapValueVarName += QString::number(partNum + 1);
}
code += QString::fromLatin1("const KDSoapValue %1 = %2.childValues().at(%3);").arg(soapValueVarName, requestVarName).arg(partNum) + COMMENT;
}
// what if there's more than one?
code.addBlock(demarshalVar(part.type(), part.element(), varName, argType, soapValueVarName, false, false));
inputVars += varName;
newClass.addIncludes(mTypeMap.headerIncludes(part.type()), mTypeMap.forwardDeclarationsForElement(part.element()));
virtualMethod.addArgument(mTypeMap.localInputType(part.type(), part.element()) + ' ' + varName);
}
}
const Part::List outParts = outputMessage.parts();
if (outParts.count() > 1) {
qWarning("ERROR: multiple output parameters are not supported (operation %s) - please file"
"an issue on github with your wsdl file", qPrintable(operation.name()));
virtualMethod.setReturnType("void /*UNSUPPORTED*/");
} else if (outParts.isEmpty()) {
code += lowerlize(operationName) + '(' + inputVars.join(", ") + ");";
virtualMethod.setReturnType("void");
} else {
QString retType;
QString retInputType;
//bool isBuiltin = false;
//bool isComplex = false;
Part retPart;
Q_FOREACH (const Part &outPart, outParts /* only one */) {
retType = mTypeMap.localType(outPart.type(), outPart.element());
retInputType = mTypeMap.localInputType(outPart.type(), outPart.element());
//isBuiltin = mTypeMap.isBuiltinType( outPart.type(), outPart.element() );
//isComplex = mTypeMap.isComplexType( outPart.type(), outPart.element() );
retPart = outPart;
}
const QString methodCall = methodName + '(' + inputVars.join(", ") + ')';
if (retType == "void") {
code += methodCall + ";" + COMMENT;
} else {
code += retType + " ret = " + methodCall + ";" + COMMENT;
}
code += "if (!hasFault()) {";
code.indent();
// TODO factorize with same code in next method
if (soapStyle(binding) == SoapBinding::DocumentStyle) {
code.addBlock(serializePart(retPart, "ret", responseVarName, false));
} else {
code += QString("KDSoapValue wrapper(\"%1\", QVariant(), \"%2\");").arg(outputMessage.name()).arg(outputMessage.nameSpace());
code.addBlock(serializePart(retPart, "ret", "wrapper.childValues()", true));
code += responseVarName + " = wrapper;";
}
code.unindent();
code += "}";
Q_ASSERT(!retType.isEmpty());
virtualMethod.setReturnType(retType);
newClass.addIncludes(mTypeMap.headerIncludes(retPart.type()), mTypeMap.forwardDeclarationsForElement(retPart.element()));
generateDelayedReponseMethod(methodName, retInputType, retPart, newClass, binding, outputMessage);
}
void Converter::convertServerService()
{
Q_FOREACH (const Service &service, mWSDL.definitions().services()) {
Q_ASSERT(!service.name().isEmpty());
QSet<QName> uniqueBindings = mWSDL.uniqueBindings(service);
Q_FOREACH (const QName &bindingName, uniqueBindings) {
//qDebug() << "binding" << bindingName;
const Binding binding = mWSDL.findBinding(bindingName);
QString className = KODE::Style::className(service.name());
QString nameSpace;
if (uniqueBindings.count() > 1) {
// Multiple bindings: use Service::Binding as classname.
nameSpace = className;
className = KODE::Style::className(bindingName.localName());
}
className += "ServerBase";
KODE::Class serverClass(className, nameSpace);
serverClass.addBaseClass(mQObject);
serverClass.addBaseClass(mKDSoapServerObjectInterface);
if (!Settings::self()->exportDeclaration().isEmpty()) {
serverClass.setExportDeclaration(Settings::self()->exportDeclaration());
}
serverClass.setNameSpace(Settings::self()->nameSpace());
// Files included in the header
serverClass.addHeaderInclude("QtCore/QObject");
serverClass.addHeaderInclude("KDSoapServer/KDSoapServerObjectInterface.h");
serverClass.addDeclarationMacro("Q_OBJECT");
serverClass.addDeclarationMacro("Q_INTERFACES(KDSoapServerObjectInterface)");
KODE::Function processRequestMethod(QString::fromLatin1("processRequest"), QString::fromLatin1("void"));
processRequestMethod.addArgument("const KDSoapMessage &_request");
processRequestMethod.addArgument("KDSoapMessage &_response");
processRequestMethod.addArgument("const QByteArray& _soapAction");
KODE::Code body;
const QString responseNs = mWSDL.definitions().targetNamespace();
body.addLine("setResponseNamespace(QLatin1String(\"" + responseNs + "\"));" + COMMENT);
body.addLine("const QByteArray method = _request.name().toLatin1();");
PortType portType = mWSDL.findPortType(binding.portTypeName());
//qDebug() << portType.name();
bool first = true;
const Operation::List operations = portType.operations();
Q_FOREACH (const Operation &operation, operations) {
const Operation::OperationType opType = operation.operationType();
switch (opType) {
case Operation::OneWayOperation:
case Operation::RequestResponseOperation: // the standard case
case Operation::SolicitResponseOperation:
case Operation::NotificationOperation:
generateServerMethod(body, binding, operation, serverClass, first);
break;
}
first = false;
}
if (!first) {
body += "else {";
body.indent();
}
body += "KDSoapServerObjectInterface::processRequest(_request, _response, _soapAction);" + COMMENT;
if (!first) {
body.unindent();
body += "}";
}
processRequestMethod.setBody(body);
serverClass.addFunction(processRequestMethod);
mClasses.addClass(serverClass);
}
}
}
KODE::Code ElementArgumentSerializer::generate() const
{
Q_ASSERT(!mLocalVarName.isEmpty());
Q_ASSERT(!mOutputVarName.isEmpty());
const QString varAndMethodBefore = mOutputVarName + (mAppend ? QLatin1String(".append(") : QLatin1String(" = "));
const QString varAndMethodAfter = mAppend ? QString::fromLatin1(")") : QString();
KODE::Code block;
// for debugging, add this:
//block += "// type: " + type.qname() + " element:" + elementType.qname();
//if ( name.localName() == "..." )
// qDebug() << "appendElementArg:" << name << "type=" << type << "isBuiltin=" << mTypeMap.isBuiltinType(type) << "isQualified=" << isQualified;
if ( mTypeMap.isTypeAny( mType ) ) {
block += QLatin1String("if (!") + mLocalVarName + QLatin1String(".isNull()) {");
block.indent();
block += varAndMethodBefore + mLocalVarName + varAndMethodAfter + QLatin1String(";") + COMMENT;
block.unindent();
block += "}";
} else {
const QName actualType = mType.isEmpty() ? mElementType : mType;
const QString typeArgs = namespaceString(actualType.nameSpace()) + QLatin1String(", QString::fromLatin1(\"") + actualType.localName() + QLatin1String("\")");
const bool isComplex = mTypeMap.isComplexType( mType, mElementType );
const bool isPolymorphic = mTypeMap.isPolymorphic( mType, mElementType );
if ( mAppend && mOmitIfEmpty ) {
if ( mUsePointer ) {
block += "if (" + mLocalVarName + ") {";
} else {
block += "if (!" + mLocalVarName + "_nil) {";
}
block.indent();
}
if ( isComplex ) {
const QString op = (isPolymorphic || mUsePointer) ? "->" : ".";
block += QLatin1String("KDSoapValue ") + mValueVarName + QLatin1Char('(') + mLocalVarName + op + QLatin1String("serialize(") + mNameArg + QLatin1String("));") + COMMENT;
} else {
if ( mTypeMap.isBuiltinType( mType, mElementType ) ) {
const QString qtTypeName = mTypeMap.localType( mType, mElementType );
const QString value = mTypeMap.serializeBuiltin( mType, mElementType, mLocalVarName, qtTypeName );
block += QLatin1String("KDSoapValue ") + mValueVarName + QLatin1String("(" )+ mNameArg + QLatin1String(", ") + value + QLatin1String(", ") + typeArgs + QLatin1String(");") + COMMENT;
} else {
block += QLatin1String("KDSoapValue ") + mValueVarName + QLatin1String("(") + mNameArg + QLatin1String(", ") + mLocalVarName + QLatin1String(".serialize(), ") + typeArgs + QLatin1String(");") + COMMENT;
}
}
if ( !mNameNamespace.isEmpty() )
block += mValueVarName + QLatin1String(".setNamespaceUri(") + mNameNamespace + QLatin1String(");");
if ( mIsQualified )
block += mValueVarName + QLatin1String(".setQualified(true);");
if ( mNillable )
block += mValueVarName + QLatin1String(".setNillable(true);");
if ( mAppend && mOmitIfEmpty ) { // omit empty children (testcase: MSExchange, no <ParentFolderIds/>)
block += "if (!" + mValueVarName + ".isNil())";
}
block += varAndMethodBefore + mValueVarName + varAndMethodAfter + QLatin1String(";") + COMMENT;
if ( mAppend && mOmitIfEmpty ) {
block.unindent();
block += "}";
}
}
return block;
}
void Converter::generateServerMethod(KODE::Code& code, const Binding& binding, const Operation& operation, KODE::Class &newClass, bool first)
{
const Message message = mWSDL.findMessage( operation.input().message() );
Message outputMessage;
if (operation.operationType() != Operation::OneWayOperation) {
outputMessage = mWSDL.findMessage( operation.output().message() );
}
const QString operationName = operation.name();
const QString methodName = mNameMapper.escape( lowerlize( operationName ) );
KODE::Function virtualMethod(methodName);
virtualMethod.setVirtualMode(KODE::Function::PureVirtual);
QString condition = "method == \"" + operationName + "\"";
if ( binding.type() == Binding::SOAPBinding ) {
const SoapBinding soapBinding( binding.soapBinding() );
const SoapBinding::Operation op = soapBinding.operations().value( operation.name() );
if (!op.action().isEmpty()) {
condition += "|| soapAction == \"" + op.action() + "\"";
}
}
code += QString(first ? "" : "else ") + "if (" + condition + ") {";
code.indent();
QStringList inputVars;
const Part::List parts = message.parts();
if (parts.count() > 1) {
qWarning("ERROR: multiple input parameters are not supported - please report this with your wsdl file to [email protected]");
}
Q_FOREACH( const Part& part, parts ) {
const QString lowerName = lowerlize( part.name() );
const QString argType = mTypeMap.localType( part.type(), part.element() );
//qDebug() << "localInputType" << part.type().qname() << part.element().qname() << "->" << argType;
if ( argType != "void" ) {
const QString varName = mNameMapper.escape( lowerName );
code += argType + ' ' + varName + ";" + COMMENT;
QString soapValueVarName = "request";
if (soapStyle(binding) == SoapBinding::RPCStyle) {
// RPC comes with a wrapper element, dig into it here
code += QLatin1String("const KDSoapValue val = request.childValues().first();") + COMMENT;
soapValueVarName = "val";
}
// what if there's more than one?
code.addBlock( demarshalVar( part.type(), part.element(), varName, argType, soapValueVarName ) );
inputVars += varName;
newClass.addIncludes( mTypeMap.headerIncludes( part.type() ) );
virtualMethod.addArgument( mTypeMap.localInputType( part.type(), part.element() ) + ' ' + varName );
}
}
const Part::List outParts = outputMessage.parts();
if (outParts.count() > 1) {
qWarning("ERROR: multiple output parameters are not supported (operation %s) - please report"
" this with your wsdl file to [email protected]", qPrintable(operation.name()));
virtualMethod.setReturnType("void /*UNSUPPORTED*/");
} else if (outParts.isEmpty()) {
code += operationName + '(' + inputVars.join(", ") + ");";
virtualMethod.setReturnType("void");
} else {
QString retType;
QString retInputType;
//bool isBuiltin = false;
//bool isComplex = false;
Part retPart;
Q_FOREACH( const Part& outPart, outParts /* only one */ ) {
retType = mTypeMap.localType( outPart.type(), outPart.element() );
retInputType = mTypeMap.localInputType( outPart.type(), outPart.element() );
//isBuiltin = mTypeMap.isBuiltinType( outPart.type(), outPart.element() );
//isComplex = mTypeMap.isComplexType( outPart.type(), outPart.element() );
retPart = outPart;
}
const QString methodCall = methodName + '(' + inputVars.join(", ") + ')';
if (retType == "void") {
code += methodCall + ";" + COMMENT;
} else {
code += retType + " ret = " + methodCall + ";" + COMMENT;
}
code += "if (!hasFault()) {";
code.indent();
bool qualified;
const QName elemName = elementNameForPart( retPart, &qualified );
if (soapStyle(binding) == SoapBinding::RPCStyle) {
code += QString("KDSoapValue wrapper(\"%1\", QVariant());").arg(outputMessage.name());
code.addBlock( serializeElementArg( retPart.type(), retPart.element(), elemName, "ret", "wrapper.childValues()", true, qualified ) );
code += "response = wrapper;";
} else {
code.addBlock( serializeElementArg( retPart.type(), retPart.element(), elemName, "ret", "response", false, qualified ) );
}
code.unindent();
code += "}";
Q_ASSERT(!retType.isEmpty());
virtualMethod.setReturnType(retType);
generateDelayedReponseMethod(methodName, retInputType, retPart, newClass, binding, outputMessage);
}
void Converter::convertSimpleType( const XSD::SimpleType *type )
{
const QString typeName( mTypeMap.localType( type->qualifiedName() ) );
KODE::Class newClass( typeName );
newClass.addInclude( QString(), "Serializer" );
KODE::Code ctorBody;
KODE::Code dtorBody;
QString classDocumentation;
if ( type->subType() == XSD::SimpleType::TypeRestriction ) {
/**
Use setter and getter method for enums as well.
*/
if ( type->facetType() & XSD::SimpleType::ENUM ) {
classDocumentation = "This class is a wrapper for an enumeration.\n";
QStringList enums = type->facetEnums();
for ( int i = 0; i < enums.count(); ++i )
enums[ i ] = escapeEnum( enums[ i ] );
newClass.addEnum( KODE::Enum( "Type", enums ) );
classDocumentation += "Whenever you have to pass an object of type " + newClass.name() +
" you can also pass the enum directly (e.g. someMethod( " + newClass.name() + "::" + enums.first() + " )).";
// member variables
KODE::MemberVariable variable( "type", "Type" );
newClass.addMemberVariable( variable );
// setter method
KODE::Function setter( "setType", "void" );
setter.addArgument( "Type type" );
setter.setBody( variable.name() + " = type;" );
// getter method
KODE::Function getter( "type", upperlize( newClass.name() ) + "::Type" );
getter.setBody( "return " + variable.name() + ';' );
getter.setConst( true );
// convenience constructor
KODE::Function conctor( upperlize( newClass.name() ) );
conctor.addArgument( "const " + upperlize( newClass.name() ) + "::Type &type" );
KODE::Code code;
code += variable.name() + " = type;";
conctor.setBody( code );
// type operator
KODE::Function op( "operator const " + upperlize( newClass.name() ) + "::Type" );
op.setBody( "return " + variable.name() + ';' );
op.setConst( true );
newClass.addFunction( conctor );
newClass.addFunction( setter );
newClass.addFunction( getter );
newClass.addFunction( op );
}
/**
A class can't derive from basic types (e.g. int or unsigned char), so
we add setter and getter methods to set the value of this class.
*/
if ( type->baseTypeName() != XmlAnyType
&& !type->baseTypeName().isEmpty()
&& !(type->facetType() & XSD::SimpleType::ENUM) ) {
classDocumentation = "This class encapsulates an basic type.\n";
const QName baseName = type->baseTypeName();
const QString typeName = mTypeMap.localType( baseName );
classDocumentation += "Whenever you have to pass an object of type " + newClass.name() +
" you can also pass the value directly (e.g. someMethod( (" + typeName + "*)value )).";
// include header
newClass.addIncludes( QStringList(), mTypeMap.forwardDeclarations( baseName ) );
// member variables
KODE::MemberVariable variable( "value", typeName + '*' );
newClass.addMemberVariable( variable );
ctorBody += variable.name() + " = 0;";
dtorBody += "delete " + variable.name() + "; " + variable.name() + " = 0;";
// setter method
KODE::Function setter( "setValue", "void" );
setter.addArgument( typeName + " *value" );
KODE::Code setterBody;
setterBody += createRangeCheckCode( type, "(*value)", newClass );
setterBody.newLine();
setterBody += "if ( !rangeOk )";
setterBody.indent();
setterBody += "qDebug( \"Invalid range in " + newClass.name() + "::" + setter.name() + "()\" );";
setterBody.unindent();
setterBody.newLine();
setterBody += variable.name() + " = value;";
setter.setBody( setterBody );
// getter method
KODE::Function getter( "value", typeName + '*' );
getter.setBody( "return " + variable.name() + ';' );
getter.setConst( true );
// convenience constructor
KODE::Function conctor( upperlize( newClass.name() ) );
conctor.addArgument( typeName + " *value" );
KODE::Code code;
code += createRangeCheckCode( type, "(*value)", newClass );
code.newLine();
code += "if ( !rangeOk )";
code.indent();
code += "qDebug( \"Invalid range in " + newClass.name() + "::" + conctor.name() + "()\" );";
code.unindent();
code.newLine();
code += variable.name() + " = value;";
conctor.setBody( code );
if ( typeName == "QString" ) {
KODE::Function charctor( upperlize( newClass.name() ) );
charctor.addArgument( "const char *charValue" );
KODE::Code code;
code += "QString *value = new QString( charValue );";
code += createRangeCheckCode( type, "(*value)", newClass );
code.newLine();
code += "if ( !rangeOk )";
code.indent();
code += "qDebug( \"Invalid range in " + newClass.name() + "::" + charctor.name() + "()\" );";
code.unindent();
code.newLine();
code += variable.name() + " = value;";
charctor.setBody( code );
newClass.addFunction( charctor );
}
// type operator
KODE::Function op( "operator const " + typeName + '*' );
op.setBody( "return " + variable.name() + ';' );
op.setConst( true );
newClass.addFunction( conctor );
newClass.addFunction( op );
newClass.addFunction( setter );
newClass.addFunction( getter );
}
} else if ( type->subType() == XSD::SimpleType::TypeList ) {
classDocumentation = "This class encapsulates a list type.";
newClass.addHeaderInclude( "QList" );
const QName baseName = type->listTypeName();
const QString typeName = mTypeMap.localType( baseName );
// include header
newClass.addIncludes( QStringList(), mTypeMap.forwardDeclarations( baseName ) );
// member variables
KODE::MemberVariable variable( "entries", "QList<" + typeName + "*>*" );
newClass.addMemberVariable( variable );
ctorBody += variable.name() + " = 0;";
dtorBody += "qDeleteAll( *" + variable.name() + " );";
dtorBody += variable.name() + "->clear();";
dtorBody += "delete " + variable.name() + "; " + variable.name() + " = 0;";
// setter method
KODE::Function setter( "setEntries", "void" );
setter.addArgument( "QList<" + typeName + "*> *entries" );
setter.setBody( variable.name() + " = entries;" );
// getter method
KODE::Function getter( "entries", "QList<" + typeName + "*>*" );
getter.setBody( "return " + variable.name() + ';' );
getter.setConst( true );
newClass.addFunction( setter );
newClass.addFunction( getter );
}
if ( !type->documentation().isEmpty() )
newClass.setDocs( type->documentation().simplified() );
else
newClass.setDocs( classDocumentation );
createSimpleTypeSerializer( type );
KODE::Function ctor( upperlize( newClass.name() ) );
ctor.setBody( ctorBody );
newClass.addFunction( ctor );
KODE::Function dtor( '~' + upperlize( newClass.name() ) );
dtor.setBody( dtorBody );
newClass.addFunction( dtor );
mClasses.append( newClass );
}
void Converter::createTransportClass()
{
KODE::Class transport( "Transport" );
transport.addBaseClass( mQObject );
transport.addHeaderInclude( "qobject.h" );
transport.addHeaderInclude( "kio/job.h" );
transport.addInclude( "kdebug.h" );
KODE::MemberVariable url( "url", "QString" );
transport.addMemberVariable( url );
KODE::MemberVariable slotDataVar( "data", "QByteArray" );
transport.addMemberVariable( slotDataVar );
// ctor
KODE::Function ctor( "Transport" );
ctor.addArgument( "const QString &url" );
ctor.setBody( url.name() + " = url;" );
transport.addFunction( ctor );
// query
KODE::Function query( "query", "void" );
query.addArgument( "const QString &xml" );
KODE::Code queryCode;
queryCode += slotDataVar.name() + ".truncate( 0 );";
queryCode.newLine();
queryCode += "QByteArray postData;";
queryCode += "QDataStream stream( postData, IO_WriteOnly );";
queryCode += "stream.writeRawBytes( xml.utf8(), xml.utf8().length() );";
queryCode.newLine();
queryCode += "KIO::TransferJob* job = KIO::http_post( KURL( " + url.name() + " ), postData, false );";
queryCode += "if ( !job ) {";
queryCode.indent();
queryCode += "kdWarning() << \"Unable to create KIO job for \" << " + url.name() + " << endl;";
queryCode += "return;";
queryCode.unindent();
queryCode += "}";
queryCode.newLine();
queryCode += "job->addMetaData( \"UserAgent\", \"KWSDL\" );";
queryCode += "job->addMetaData( \"content-type\", \"Content-Type: text/xml; charset=utf-8\" );";
queryCode.newLine();
queryCode += "connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );";
queryCode += "connect( job, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotResult( KIO::Job* ) ) );";
query.setBody( queryCode );
transport.addFunction( query );
// signal
KODE::Function result( "result", "void", KODE::Function::Signal );
result.addArgument( "const QString &xml" );
transport.addFunction( result );
// data slot
KODE::Function slotData( "slotData", "void", KODE::Function::Private | KODE::Function::Slot );
slotData.addArgument( "KIO::Job*" );
slotData.addArgument( "const QByteArray &data" );
KODE::Code slotDataCode;
slotDataCode += "unsigned int oldSize = " + slotDataVar.name() + ".size();";
slotDataCode += slotDataVar.name() + ".resize( oldSize + data.size() );";
slotDataCode += "memcpy( " + slotDataVar.name() + ".data() + oldSize, data.data(), data.size() );";
slotData.setBody( slotDataCode );
transport.addFunction( slotData );
// result slot
KODE::Function slotResult( "slotResult", "void", KODE::Function::Private | KODE::Function::Slot );
slotResult.addArgument( "KIO::Job* job" );
KODE::Code slotResultCode;
slotResultCode += "if ( job->error() != 0 ) {";
slotResultCode.indent();
slotResultCode += "kdWarning() << \"Error occurred \" << job->errorText() << endl;";
slotResultCode += "kdWarning() << " + slotDataVar.name() + " << endl;";
slotResultCode += "return;";
slotResultCode.unindent();
slotResultCode += "}";
slotResultCode.newLine();
slotResultCode += "emit result( QString::fromUtf8( " + slotDataVar.name() + ".data(), " + slotDataVar.name() + ".size() ) );";
slotResult.setBody( slotResultCode );
transport.addFunction( slotResult );
mClasses.append( transport );
}
void Converter::createUtilClasses()
{
mSerializer = KODE::Class( "Serializer" );
mSerializer.addHeaderInclude( "qcstring.h" );
mSerializer.addHeaderInclude( "qdom.h" );
mSerializer.addHeaderInclude( "qdatetime.h" );
mSerializer.addHeaderInclude( "qstring.h" );
mSerializer.addHeaderInclude( "qptrlist.h" );
mSerializer.addInclude( "kmdcodec.h" );
typedef struct {
QString type;
QString xsdType;
QString marshalCode;
QString demarshalCode;
} TypeEntry;
/**
I know the following code looks a bit ugly, but it saves us a lot
of typing and is easier to maintain at the end ;)
*/
TypeEntry types[] = {
{ "QString", "xsd:string", "*value", "str" },
{ "bool", "xsd:boolean", "(*value ? \"true\" : \"false\")", "(str.lower() == \"true\" ? true : false)" },
{ "float", "xsd:TODO", "QString::number( *value )", "str.toFloat()" },
{ "int", "xsd:int", "QString::number( *value )", "str.toInt()" },
{ "unsigned int", "xsd:unsignedByte", "QString::number( *value )", "str.toUInt()" },
{ "double", "xsd:double", "QString::number( *value )", "str.toDouble()" },
{ "char", "xsd:byte", "QString( QChar( *value ) )", "str[ 0 ].latin1()" },
{ "unsigned char", "xsd:unsignedByte", "QString( QChar( *value ) )", "str[ 0 ].latin1()" },
{ "short", "xsd:short", "QString::number( *value )", "str.toShort()" },
{ "QByteArray", "xsd:base64Binary", "QString::fromUtf8( KCodecs::base64Encode( *value ) )", "KCodecs::base64Decode( str.utf8() )" },
{ "QDateTime", "xsd:dateTime", "value->toString( Qt::ISODate )", "QDateTime::fromString( str, Qt::ISODate )" },
{ "QDate", "xsd:date", "value->toString( Qt::ISODate )", "QDate::fromString( str, Qt::ISODate )" }
};
for ( uint i = 0; i < sizeof( types ) / sizeof( TypeEntry ); ++i ) {
KODE::Function marshal, demarshal;
KODE::Code code;
TypeEntry entry = types[ i ];
marshal = KODE::Function( "marshalValue", "QString" );
marshal.setStatic( true );
marshal.addArgument( "const " + entry.type + "* value" );
code.clear();
marshal.setBody( "return " + entry.marshalCode + ";" );
mSerializer.addFunction( marshal );
demarshal = KODE::Function( "demarshalValue", "void" );
demarshal.setStatic( true );
demarshal.addArgument( "const QString &str" );
demarshal.addArgument( entry.type + " *value" );
demarshal.setBody( "*value = " + entry.demarshalCode + ";" );
mSerializer.addFunction( demarshal );
marshal = KODE::Function( "marshal", "void" );
marshal.setStatic( true );
marshal.addArgument( "QDomDocument &doc" );
marshal.addArgument( "QDomElement &parent" );
marshal.addArgument( "const QString &name" );
marshal.addArgument( "const " + entry.type + "* value" );
code.clear();
code += "QDomElement element = doc.createElement( name );";
code += "element.setAttribute( \"xsi:type\", \"" + entry.xsdType + "\" );";
code += "element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );";
code += "parent.appendChild( element );";
marshal.setBody( code );
mSerializer.addFunction( marshal );
demarshal = KODE::Function( "demarshal", "void" );
demarshal.setStatic( true );
demarshal.addArgument( "const QDomElement &element" );
demarshal.addArgument( entry.type + "* value" );
demarshal.setBody( "Serializer::demarshalValue( element.text(), value );" );
mSerializer.addFunction( demarshal );
}
}
void Converter::convertSimpleType(const XSD::SimpleType *type, const XSD::SimpleType::List &simpleTypeList)
{
const QString typeName(mTypeMap.localType(type->qualifiedName()));
//qDebug() << "convertSimpleType:" << type->qualifiedName() << typeName;
KODE::Class newClass;
newClass.setNamespaceAndName(typeName);
if (!Settings::self()->exportDeclaration().isEmpty()) {
newClass.setExportDeclaration(Settings::self()->exportDeclaration());
}
newClass.setNameSpace(Settings::self()->nameSpace());
QString classDocumentation;
switch (type->subType()) {
case XSD::SimpleType::TypeRestriction: {
/**
Use setter and getter method for enums as well.
*/
if (type->facetType() & XSD::SimpleType::ENUM) {
classDocumentation = "This class is a wrapper for an enumeration.\n";
NameMapper nameMapper;
QStringList enums = type->facetEnums();
for (int i = 0; i < enums.count(); ++i) {
enums[ i ] = nameMapper.escape(escapeEnum(enums[ i ]));
}
newClass.addEnum(KODE::Enum("Type", enums));
classDocumentation += "Whenever you have to pass an object of type " + newClass.name() +
" you can also pass the enum directly. Example:\n" +
"someMethod(" + newClass.name() + "::" + enums.first() + ").";
// member variables
KODE::MemberVariable variable("type", "Type");
variable.setInitializer("Type(0)");
newClass.addMemberVariable(variable);
// setter method
KODE::Function setter("setType", "void");
setter.addArgument("Type type");
setter.setBody(variable.name() + " = type;");
// getter method
KODE::Function getter("type", newClass.qualifiedName() + "::Type");
getter.setBody("return " + variable.name() + ';');
getter.setConst(true);
// convenience constructor
KODE::Function conctor(newClass.name());
conctor.addArgument("const Type &type");
KODE::Code code;
code += variable.name() + " = type;";
conctor.setBody(code);
// type operator
KODE::Function op("operator Type");
op.setBody("return " + variable.name() + ';');
op.setConst(true);
newClass.addFunction(conctor);
newClass.addFunction(setter);
newClass.addFunction(getter);
newClass.addFunction(op);
}
/**
A class can't derive from basic types (e.g. int or unsigned char), so
we add setter and getter methods to set the value of this class.
*/
if (type->baseTypeName() != XmlAnyType
&& !type->baseTypeName().isEmpty()
&& !(type->facetType() & XSD::SimpleType::ENUM)) {
classDocumentation = "This class encapsulates a simple type.\n";
const QName baseName = type->baseTypeName();
const QString baseTypeName = mTypeMap.localType(baseName);
Q_ASSERT(!baseTypeName.isEmpty());
QList<QName> parentBasicTypes;
parentBasicTypes.append(baseName);
QName currentType = baseName;
Q_FOREVER {
const XSD::SimpleType simpleType = simpleTypeList.simpleType(currentType);
if (!simpleType.isNull() && simpleType.isRestriction()) {
currentType = simpleType.baseTypeName();
parentBasicTypes.append(currentType);
continue;
}
break;
}
classDocumentation += "Whenever you have to pass an object of type " + newClass.name() +
" you can also pass the value directly as a " + mTypeMap.localType(currentType) + '.';
// include header
newClass.addIncludes(QStringList(), mTypeMap.forwardDeclarations(baseName));
newClass.addHeaderIncludes(mTypeMap.headerIncludes(baseName));
// member variables
KODE::MemberVariable variable("value", baseTypeName);
addVariableInitializer(variable);
newClass.addMemberVariable(variable);
// setter method
KODE::Function setter("setValue", "void");
const QString inputType = mTypeMap.localInputType(baseName, QName());
setter.addArgument(inputType + " value");
KODE::Code setterBody;
if (type->facetType() != XSD::SimpleType::NONE) {
const XSD::SimpleType baseSimpleType = simpleTypeList.simpleType(baseName);
setterBody += createRangeCheckCode(type, baseTypeName, "value", newClass, baseSimpleType);
setterBody.newLine();
setterBody += "if (!rangeOk)";
setterBody.indent();
setterBody += "qDebug( \"Invalid range in " + newClass.name() + "::" + setter.name() + "()\" );";
setterBody.unindent();
setterBody.newLine();
}
setterBody += variable.name() + " = value;"; // ### call setValue in base class?
setter.setBody(setterBody);
newClass.addFunction(setter);
// getter method
KODE::Function getter("value", baseTypeName);
getter.setBody("return " + variable.name() + ';');
getter.setConst(true);
newClass.addFunction(getter);
// convenience constructor
KODE::Function conctor(newClass.name());
conctor.addArgument(inputType + " value");
conctor.addBodyLine("setValue(value);");
newClass.addFunction(conctor);
// even more convenient constructor, for the case of multiple-level simple-type restrictions
//qDebug() << typeName << ": baseName=" << baseName << "further up:" << parentBasicTypes;
if (parentBasicTypes.count() > 1) {
parentBasicTypes.removeLast(); // the top-most one is in "currentType", so it's the input arg.
KODE::Function baseCtor(conctor.name());
baseCtor.addArgument(mTypeMap.localInputType(currentType, QName()) + " value");
QString beginLine = "setValue(";
QString endLine = ")";
Q_FOREACH (const QName &base, parentBasicTypes) {
beginLine += mTypeMap.localType(base) + '(';
endLine += ')';
}
baseCtor.addBodyLine(beginLine + "value" + endLine + ';');
newClass.addFunction(baseCtor);
}
// type operator
KODE::Function op("operator " + baseTypeName);
op.setBody("return " + variable.name() + ';');
op.setConst(true);
newClass.addFunction(op);
}
void Converter::createKDETransport()
{
KODE::Class transport( "Transport" );
transport.addBaseClass( mQObject );
transport.addHeaderInclude( "QObject" );
transport.addHeaderInclude( "kio/job.h" );
transport.addInclude( "kdebug.h" );
KODE::MemberVariable url( "url", "QString" );
transport.addMemberVariable( url );
KODE::MemberVariable slotDataVar( "data", "QByteArray" );
transport.addMemberVariable( slotDataVar );
// ctor
KODE::Function ctor( "Transport" );
ctor.addArgument( "const QString &url" );
ctor.setBody( url.name() + " = url;" );
transport.addFunction( ctor );
// query
KODE::Function query( "query", "void" );
query.addArgument( "const QString &xml" );
query.addArgument( "const QString &header" );
KODE::Code queryCode;
queryCode += slotDataVar.name() + ".truncate( 0 );";
queryCode.newLine();
queryCode += "QByteArray postData;";
queryCode += "QDataStream stream( &postData, QIODevice::WriteOnly );";
queryCode += "stream.writeRawData( xml.toUtf8(), xml.toUtf8().length() );";
queryCode.newLine();
queryCode += "KIO::TransferJob* job = KIO::http_post( KUrl( " + url.name() + " ), postData, KIO::HideProgressInfo );";
queryCode += "if ( !job ) {";
queryCode.indent();
queryCode += "kWarning() << \"Unable to create KIO job for \" <<" + url.name() +";";
queryCode += "return;";
queryCode.unindent();
queryCode += '}';
queryCode.newLine();
queryCode += "job->addMetaData( \"UserAgent\", \"KWSDL\" );";
queryCode += "job->addMetaData( \"content-type\", \"Content-Type: application/xml; charset=utf-8\" );";
queryCode += "if ( !header.isEmpty() ) {";
queryCode.indent();
queryCode += "job->addMetaData( \"customHTTPHeader\", \"SOAPAction:\" + header );";
queryCode.unindent();
queryCode += '}';
queryCode.newLine();
queryCode += "connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );";
queryCode += "connect( job, SIGNAL( result( KJob* ) ), this, SLOT( slotResult( KJob* ) ) );";
query.setBody( queryCode );
transport.addFunction( query );
// signal
KODE::Function result( "result", "void", KODE::Function::Signal );
result.addArgument( "const QString &xml" );
KODE::Function error( "error", "void", KODE::Function::Signal );
error.addArgument( "const QString &msg" );
transport.addFunction( result );
transport.addFunction( error );
// data slot
KODE::Function slotData( "slotData", "void", KODE::Function::Private | KODE::Function::Slot );
slotData.addArgument( "KIO::Job*" );
slotData.addArgument( "const QByteArray &data" );
KODE::Code slotDataCode;
slotDataCode += "unsigned int oldSize = " + slotDataVar.name() + ".size();";
slotDataCode += slotDataVar.name() + ".resize( oldSize + data.size() );";
slotDataCode += "memcpy( " + slotDataVar.name() + ".data() + oldSize, data.data(), data.size() );";
slotData.setBody( slotDataCode );
transport.addFunction( slotData );
// result slot
KODE::Function slotResult( "slotResult", "void", KODE::Function::Private | KODE::Function::Slot );
slotResult.addArgument( "KJob* job" );
KODE::Code slotResultCode;
slotResultCode += "if ( job->error() != 0 ) {";
slotResultCode.indent();
slotResultCode += "emit error( job->errorText() );";
slotResultCode += "return;";
slotResultCode.unindent();
slotResultCode += '}';
slotResultCode.newLine();
slotResultCode += "emit result( QString::fromUtf8( " + slotDataVar.name() + ".data(), " + slotDataVar.name() + ".size() ) );";
slotResult.setBody( slotResultCode );
transport.addFunction( slotResult );
mClasses.append( transport );
}
void Converter::createQtTransport()
{
KODE::Class transport( "Transport" );
transport.addBaseClass( mQObject );
transport.addHeaderInclude( "QBuffer" );
transport.addHeaderInclude( "QByteArray" );
transport.addHeaderInclude( "QObject" );
transport.addHeaderInclude( "QHttp" );
transport.addHeaderInclude( "QUrl" );
// member variables
KODE::MemberVariable bufferVar( "buffer", "QBuffer" );
transport.addMemberVariable( bufferVar );
KODE::MemberVariable dataVar( "data", "QByteArray" );
transport.addMemberVariable( dataVar );
KODE::MemberVariable httpVar( "http", "QHttp*" );
transport.addMemberVariable( httpVar );
KODE::MemberVariable urlVar( "url", "QUrl" );
transport.addMemberVariable( urlVar );
KODE::MemberVariable idVar( "id", "int" );
transport.addMemberVariable( idVar );
// functions
KODE::Function ctor( "Transport" );
ctor.addArgument( "const QString &url" );
ctor.addInitializer( "QObject( 0 )" );
ctor.addInitializer( urlVar.name() + "( url )" );
KODE::Function query( "query", "void" );
query.addArgument( "const QString &message" );
query.addArgument( "const QString &headerStr" );
KODE::Function resultSignal( "result", "void", KODE::Function::Signal );
resultSignal.addArgument( "const QString &result" );
KODE::Function errorSignal( "error", "void", KODE::Function::Signal );
errorSignal.addArgument( "const QString &msg" );
KODE::Function finishedSlot( "finished", "void", KODE::Function::Slot | KODE::Function::Private );
finishedSlot.addArgument( "int id" );
finishedSlot.addArgument( "bool errorOccurred" );
// codes
KODE::Code code;
code += "QUrl server( url );";
code.newLine();
code += httpVar.name() + " = new QHttp( this );";
code += httpVar.name() + "->setHost( server.host(), server.port( 80 ) );";
code.newLine();
code += "connect( " + httpVar.name() + ", SIGNAL( requestFinished( int, bool ) ), this, SLOT( " + finishedSlot.name() + "( int, bool ) ) );";
ctor.setBody( code );
code.clear();
code += dataVar.name() + ".clear();";
code += bufferVar.name() + ".setBuffer( &" + dataVar.name() + " );";
code.newLine();
code += "QHttpRequestHeader header;";
code += "header.setRequest( \"POST\", " + urlVar.name() + ".path() );";
code += "header.addValue( \"Connection\", \"Keep-Alive\" );";
code += "header.addValue( \"Content-Type\", \"application/xml; charset=utf-8\" );";
code += "header.addValue( \"Host\", QUrl( " + urlVar.name() + " ).host() );";
code.newLine();
code += "if ( !headerStr.isEmpty() )";
code.indent();
code += "header.addValue( \"SOAPAction\", headerStr );";
code.unindent();
code.newLine();
code += "QUrl server( " + urlVar.name() + " );";
code += "if ( server.port( 80 ) != 80 )";
code.indent();
code += "header.setValue( \"Host\", server.host() + \":\" + QString::number( server.port() ) );";
code.unindent();
code += "else";
code.indent();
code += "header.setValue( \"Host\", server.host() );";
code.unindent();
code.newLine();
code += idVar.name() + " = " + httpVar.name() + "->request( header, message.toUtf8(), &" + bufferVar.name() + " );";
query.setBody( code );
code.clear();
code += "if ( id != " + idVar.name() + " )";
code.indent();
code += "return;";
code.unindent();
code.newLine();
code += "if ( errorOccurred )";
code.indent();
code += "emit " + errorSignal.name() + "( " + httpVar.name() + "->errorString() );";
code.unindent();
code += "else";
code.indent();
code += "emit " + resultSignal.name() + "( QString::fromUtf8( " + dataVar.name() + " ) );";
code.unindent();
finishedSlot.setBody( code );
transport.addFunction( ctor );
transport.addFunction( query );
transport.addFunction( resultSignal );
transport.addFunction( errorSignal );
transport.addFunction( finishedSlot );
mClasses.append( transport );
}
int create(KCmdLineArgs *args)
{
KODE::Printer p;
if(args->isSet("warning")) p.setCreationWarning(true);
bool createKioslave = args->isSet("create-kioslave");
bool createMain = args->isSet("create-main");
QString filename = args->getOption("filename");
if(createMain)
{
if(filename.isEmpty())
{
kdError() << "Error: No file name given." << endl;
return 1;
}
if(filename.endsWith(".cpp"))
{
filename = filename.left(filename.length() - 4);
}
}
else
{
if(!args->isSet("classname"))
{
kdError() << "Error: No class name given." << endl;
return 1;
}
}
QString className = args->getOption("classname");
QString protocol;
if(createKioslave)
{
if(!args->isSet("protocol"))
{
protocol = className.lower();
kdWarning() << "Warning: No protocol for kioslave given. Assuming '"
<< protocol << "'" << endl;
}
else
{
protocol = args->getOption("protocol");
}
}
KODE::File file;
file.setProject(args->getOption("project"));
QString authorEmail = args->getOption("author-email");
QString authorName;
KABC::Addressee a;
if(authorEmail.isEmpty())
{
a = KABC::StdAddressBook::self()->whoAmI();
authorEmail = a.preferredEmail();
}
else
{
KABC::Addressee::List as =
KABC::StdAddressBook::self()->findByEmail(authorEmail);
if(as.isEmpty())
{
kdDebug() << "Unable to find '" << authorEmail << "' in address book."
<< endl;
}
else
{
a = as.first();
}
}
if(!a.isEmpty())
{
authorName = a.realName();
}
if(!authorEmail.isEmpty())
{
file.addCopyright(QDate::currentDate().year(), authorName, authorEmail);
}
KODE::License l;
if(args->isSet("gpl")) l = KODE::License(KODE::License::GPL);
if(args->isSet("lgpl")) l = KODE::License(KODE::License::LGPL);
l.setQtException(args->isSet("qt-exception"));
file.setLicense(l);
file.setNameSpace(args->getOption("namespace"));
if(createMain)
{
file.addInclude("kaboutdata.h");
file.addInclude("kapplication.h");
file.addInclude("kdebug");
file.addInclude("klocale");
file.addInclude("kcmdlineargs");
KODE::Code code;
code += "static const KCmdLineOptions options[] =";
code += "{";
code += " { \"verbose\", \"Verbose output\", 0 },";
code += " KCmdLineLastOption";
code += "};";
file.addFileCode(code);
KODE::Function main("main", "int");
main.addArgument("int argc");
main.addArgument("char **argv");
code.clear();
code += "KAboutData aboutData(\"test\",\"Test\",\"0.1\");";
code += "KCmdLineArgs::init(argc,argv,&aboutData);";
code += "KCmdLineArgs::addCmdLineOptions( options );";
code += "";
code += "KApplication app;";
code += "";
code += "KCmdLineArgs *args = KCmdLineArgs::parsedArgs();";
code += "";
code += "Q_UNUSED( args );";
main.setBody(code);
file.addFileFunction(main);
file.setFilename(filename);
p.printImplementation(file, false);
return 0;
}
KODE::Class c(className);
if(args->isSet("create-dialog"))
{
c.addBaseClass(KODE::Class("KDialogBase"));
c.addInclude("kdialogbase.h");
}
else if(createKioslave)
{
c.setDocs("This class implements a kioslave for ...");
c.addBaseClass(KODE::Class("SlaveBase", "KIO"));
c.addHeaderInclude("kio/slavebase.h");
KODE::Function get("get", "void");
get.addArgument("const KURL &url");
KODE::Code code;
code += "kdDebug(7000) << \"" + className + "::get()\" << endl;";
code += "kdDebug(7000) << \" URL: \" << url.url() << endl;";
code += "#if 1";
code += "kdDebug(7000) << \" Path: \" << url.path() << endl;";
code += "kdDebug(7000) << \" Query: \" << url.query() << endl;";
code += "kdDebug(7000) << \" Protocol: \" << url.protocol() << endl;";
code += "kdDebug(7000) << \" Filename: \" << url.filename() << endl;";
code += "#endif";
code.newLine();
code += "mimeType( \"text/plain\" );";
code.newLine();
code += "QCString str( \"Hello!\" );";
code += "data( str );";
code.newLine();
code += "finished();";
code.newLine();
code += "kdDebug(7000) << \"" + className + "CgiProtocol::get() done\" << endl;";
get.setBody(code);
c.addFunction(get);
c.addInclude("kinstance.h");
c.addInclude("kdebug.h");
c.addInclude("sys/types.h");
c.addInclude("unistd.h");
c.addInclude("stdlib.h");
KODE::Function main("kdemain", "int");
main.addArgument("int argc");
main.addArgument("char **argv");
code.clear();
code += "KInstance instance( \"kio_" + protocol + "\" );";
code += "";
code += "kdDebug(7000) << \"Starting kio_" + protocol + "(pid: \" << getpid() << \")\" << endl;";
code += "";
code += "if (argc != 4) {";
code.indent();
code += "fprintf( stderr, \"Usage: kio_" + protocol + " protocol domain-socket1 domain-socket2\\n\");";
code += "exit( -1 );";
code.unindent();
code += "}";
code += "";
code += className + " slave( argv[2], argv[3] );";
code += "slave.dispatchLoop();";
code += "";
code += "return 0;";
main.setBody(code);
file.addFileFunction(main);
file.addExternCDeclaration(p.functionSignature(main));
}
KODE::Function constructor(className);
if(args->isSet("singleton"))
{
constructor.setAccess(KODE::Function::Private);
KODE::Function self("self", className + " *");
self.setStatic(true);
KODE::Code code;
code += "if ( !mSelf ) {";
code += " selfDeleter.setObject( mSelf, new " + className + "() );";
code += "}";
code += "return mSelf;";
self.setBody(code);
c.addFunction(self);
KODE::MemberVariable selfVar("mSelf", className + " *", true);
selfVar.setInitializer("0");
c.addMemberVariable(selfVar);
KODE::Variable staticDeleter("selfDeleter",
"KStaticDeleter<" + className + ">",
true);
file.addFileVariable(staticDeleter);
file.addInclude("kstaticdeleter.h");
}
if(createKioslave)
{
constructor.addArgument("const QCString &pool");
constructor.addArgument("const QCString &app");
constructor.addInitializer("SlaveBase( \"" + protocol + "\", pool, app )");
}
c.addFunction(constructor);
file.insertClass(c);
p.printHeader(file);
p.printImplementation(file);
if(createKioslave)
{
// Write automake Makefile
KODE::AutoMakefile am;
am.addEntry("INCLUDES", "$(all_includes)");
am.newLine();
am.addEntry("noinst_HEADERS", className.lower() + ".h");
am.newLine();
am.addEntry("METASOURCES", "AUTO");
am.newLine();
am.addEntry("kdelnkdir", "$(kde_servicesdir)");
am.addEntry("kdelnk_DATA", protocol + ".protocol");
KODE::AutoMakefile::Target t("kde_module_LTLIBRARIES",
"kio_" + protocol + ".la");
t.setSources(className.lower() + ".cpp");
t.setLibAdd("$(LIB_KIO)");
t.setLdFlags("$(all_libraries) -module $(KDE_PLUGIN)");
am.addTarget(t);
p.printAutoMakefile(am);
// Write protocol file
QString protocolFilename = protocol + ".protocol";
QFileInfo fi(protocolFilename);
protocolFilename = fi.absFilePath();
KSaveFile::backupFile(protocolFilename, QString::null, ".backup");
QFile::remove(protocolFilename);
KSimpleConfig protocolFile(protocolFilename);
protocolFile.setGroup("Protocol");
protocolFile.writeEntry("exec", "kio_" + protocol);
protocolFile.writeEntry("protocol", protocol);
protocolFile.writeEntry("input", "none");
protocolFile.writeEntry("output", "filesystem");
protocolFile.writeEntry("reading", "true");
protocolFile.writeEntry("DocPath", "kioslave/" + protocol + ".html");
protocolFile.sync();
}
return 0;
}