C++ Procedure::GetProcedureName方法代码示例

vector<Procedure>   SpecificationParser::GetProceduresFromString(const string &content) throw(JsonRpcException)
{

    Json::Reader reader;
    Json::Value val;
    if(!reader.parse(content,val))
    {
        throw JsonRpcException(Errors::ERROR_RPC_JSON_PARSE_ERROR, " specification file contains syntax errors");
    }

    if (!val.isArray())
    {
        throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, " top level json value is not an array");
    }

    vector<Procedure> result;
    map<string, Procedure> procnames;
    for (unsigned int i = 0; i < val.size(); i++)
    {
        Procedure proc;
        GetProcedure(val[i], proc);
        if (procnames.find(proc.GetProcedureName()) != procnames.end())
        {
            throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, "Procedurename not uniqe: " + proc.GetProcedureName());
        }
        procnames[proc.GetProcedureName()] = proc;
        result.push_back(proc);
    }
    return result;
}

void CPPClientStubGenerator::generateProcCall(Procedure &proc)
{
    string call;
    if (proc.GetProcedureType() == RPC_METHOD)
    {
        call = TEMPLATE_METHODCALL;
        cg.writeLine(replaceAll(call, "<name>", proc.GetProcedureName()));
        call = TEMPLATE_RETURNCHECK;
        replaceAll2(call,"<cast>", CPPHelper::isCppConversion(proc.GetReturnType()));
        cg.writeLine(call);
        cg.increaseIndentation();
        call = TEMPLATE_RETURN;
        replaceAll2(call,"<cast>", CPPHelper::toCppConversion(proc.GetReturnType()));
        cg.writeLine(call);
        cg.decreaseIndentation();
        cg.writeLine("else");
        cg.increaseIndentation();
        cg.writeLine("throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());");
        cg.decreaseIndentation();
    }
    else
    {
        call = TEMPLATE_NOTIFICATIONCALL;
        replaceAll2(call, "<name>", proc.GetProcedureName());
        cg.writeLine(call);
    }

}

void CPPClientStubGenerator::generateMethod(Procedure &proc)
{
    string procsignature = TEMPLATE_CPPCLIENT_SIGMETHOD;
    string returntype = CPPHelper::toCppType(proc.GetReturnType());
    if (proc.GetProcedureType() == RPC_NOTIFICATION)
        returntype = "void";

    replaceAll2(procsignature, "<returntype>", returntype);
    replaceAll2(procsignature, "<methodname>", CPPHelper::normalizeString(proc.GetProcedureName()));
    replaceAll2(procsignature, "<parameters>", CPPHelper::generateParameterDeclarationList(proc));

    cg.writeLine(procsignature);
    cg.writeLine("{");
    cg.increaseIndentation();

    cg.writeLine("Json::Value p;");

    generateAssignments(proc);
    generateProcCall(proc);

    cg.decreaseIndentation();
    cg.writeLine("}");


}

int RpcProtocolServer::ValidateRequest(const Json::Value& request)
{
    int error = 0;
    Procedure* proc;
    if (!(request.isMember(KEY_REQUEST_METHODNAME)
            && request.isMember(KEY_REQUEST_VERSION)
            && request.isMember(KEY_REQUEST_PARAMETERS)))
    {
        error = Errors::ERROR_RPC_INVALID_REQUEST;
    }
    else
    {
        map<string, Procedure*>::iterator it = procedures->find(request[KEY_REQUEST_METHODNAME].asString());
        if (it != this->procedures->end())
        {
            proc = (*this->procedures)[request[KEY_REQUEST_METHODNAME].asString()];
            if(request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_NOTIFICATION)
            {
                error = Errors::ERROR_SERVER_PROCEDURE_IS_NOTIFICATION;
            }
            else if(!request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_METHOD)
            {
                error = Errors::ERROR_SERVER_PROCEDURE_IS_METHOD;
            }
            else if (proc->ValdiateParameters(request[KEY_REQUEST_PARAMETERS]))
            {
                if (this->authManager != NULL)
                {
                    error = this->authManager->CheckPermission(
                                request[KEY_AUTHENTICATION],
                                proc->GetProcedureName());
                }
            }
            else
            {
                error = Errors::ERROR_RPC_INVALID_PARAMS;
            }
        }
        else
        {
            error = Errors::ERROR_RPC_METHOD_NOT_FOUND;
        }
    }
    return error;
}

    procedurelist_t *SpecificationParser::GetProceduresFromString(const string &content) throw(JsonRpcException)
    {

        Json::Reader reader;
        Json::Value val;
        if(!reader.parse(content,val)) {
            throw JsonRpcException(Errors::ERROR_RPC_JSON_PARSE_ERROR, " specification file contains syntax errors");
        }

        procedurelist_t* procedures = new procedurelist_t();
        Procedure* proc;
        for (unsigned int i = 0; i < val.size(); i++)
        {
            proc = GetProcedure(val[i]);
            (*procedures)[proc->GetProcedureName()] = proc;
        }
        return procedures;
    }

void        SpecificationWriter::procedureToJsonValue   (const Procedure &procedure, Json::Value &target)
{
    target[KEY_SPEC_PROCEDURE_NAME] = procedure.GetProcedureName();
    if(procedure.GetProcedureType() == RPC_METHOD)
    {
        target[KEY_SPEC_RETURN_TYPE] = toJsonLiteral(procedure.GetReturnType());
    }
    for(parameterNameList_t::const_iterator it = procedure.GetParameters().begin(); it != procedure.GetParameters().end(); ++it)
    {
        if(procedure.GetParameterDeclarationType() == PARAMS_BY_NAME)
        {
            target[KEY_SPEC_PROCEDURE_PARAMETERS][it->first] = toJsonLiteral(it->second);
        }
        else
        {
            target[KEY_SPEC_PROCEDURE_PARAMETERS].append(toJsonLiteral(it->second));
        }
    }
}