Java 类com.liferay.portal.kernel.util.MethodHandler 实例源码

public static java.lang.String fooRemote(HttpPrincipal httpPrincipal) {
    try {
        MethodKey methodKey = new MethodKey(FooServiceUtil.class,
                "fooRemote", _fooRemoteParameterTypes0);

        MethodHandler methodHandler = new MethodHandler(methodKey);

        Object returnObj = null;

        try {
            returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
        }
        catch (Exception e) {
            throw new com.liferay.portal.kernel.exception.SystemException(e);
        }

        return (java.lang.String)returnObj;
    }
    catch (com.liferay.portal.kernel.exception.SystemException se) {
        _log.error(se, se);

        throw se;
    }
}

public static java.lang.String fooRemote(HttpPrincipal httpPrincipal) {
    try {
        MethodKey methodKey = new MethodKey(FooServiceUtil.class,
                "fooRemote", _fooRemoteParameterTypes0);

        MethodHandler methodHandler = new MethodHandler(methodKey);

        Object returnObj = null;

        try {
            returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
        }
        catch (Exception e) {
            throw new com.liferay.portal.kernel.exception.SystemException(e);
        }

        return (java.lang.String)returnObj;
    }
    catch (com.liferay.portal.kernel.exception.SystemException se) {
        _log.error(se, se);

        throw se;
    }
}

public static java.lang.String fooRemote(HttpPrincipal httpPrincipal) {
    try {
        MethodKey methodKey = new MethodKey(FooServiceUtil.class,
                "fooRemote", _fooRemoteParameterTypes0);

        MethodHandler methodHandler = new MethodHandler(methodKey);

        Object returnObj = null;

        try {
            returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
        }
        catch (Exception e) {
            throw new com.liferay.portal.kernel.exception.SystemException(e);
        }

        return (java.lang.String)returnObj;
    }
    catch (com.liferay.portal.kernel.exception.SystemException se) {
        _log.error(se, se);

        throw se;
    }
}

@Override
public String getSpecificDiplomaContent(){
    Object returnObj = null;

    try {
        MethodKey getNameMethod = new MethodKey(clp.getClassName(), "getSpecificDiplomaContent");
        returnObj = clp.invoke(new MethodHandler(getNameMethod));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

@Override
public String getPortletId(){
    Object returnObj = null;

    try {
        MethodKey getNameMethod = new MethodKey(clp.getClassName(), "getPortletId");
        returnObj = clp.invoke(new MethodHandler(getNameMethod));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

@Override
public String saveDiploma(UploadRequest uploadRequest,Long courseId) throws Exception{
    Object returnObj = null;
    try {
        MethodKey getNameMethod = new MethodKey(clp.getClassName(), "saveDiploma", UploadRequest.class,  Long.class);
        returnObj = clp.invoke(new MethodHandler(getNameMethod,uploadRequest, courseId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);

}

@Override
public String updateUserDiploma(Long courseResutlId){
    Object returnObj = null;
    try {
        MethodKey getNameMethod = new MethodKey(clp.getClassName(), "updateUserDiploma", Long.class);
        returnObj = clp.invoke(new MethodHandler(getNameMethod, courseResutlId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);

}

public boolean especificValidations(UploadRequest uploadRequest,PortletResponse portletResponse) {
    Object returnObj = null;

    try {
        MethodKey especificValidationsMethod = new MethodKey(clp.getClassName(), "especificValidations", UploadRequest.class, PortletResponse.class);           
        returnObj = clp.invoke(new MethodHandler(especificValidationsMethod, uploadRequest, portletResponse));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            t.printStackTrace();
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
    return ((Boolean)returnObj).booleanValue();
}

@Override
public String generateAleatoryQuestions(long actId, long typeId) {

    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "generateAleatoryQuestions", long.class, long.class);
        returnObj = clp.invoke(new MethodHandler(translateMethod, actId, typeId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
    return (String)returnObj;
}

public void setLocale(Locale locale){
    try {
        ClassLoader classLoader = clp.getClassLoader();
        Class questionTypeClass = Class.forName(QuestionType.class.getName(),true, classLoader);

        Method method = questionTypeClass.getMethod("setLocale", Locale.class); 
        clp.invoke(new MethodHandler(method, locale));

    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
}

public String getTitle(Locale locale){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("getTitle", Locale.class); 
        returnObj = clp.invoke(new MethodHandler(method, locale));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String getDescription(Locale locale){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("getDescription", Locale.class); 
        returnObj = clp.invoke(new MethodHandler(method, locale));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public void delete(long questionId) throws PortalException, SystemException{
    try {           
        Method method = QuestionType.class.getMethod("delete", long.class);
        clp.invoke(new MethodHandler(method, questionId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
}

public long correct(ActionRequest actionRequest, long questionId){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("correct", ActionRequest.class, long.class);
        returnObj = clp.invoke(new MethodHandler(method, actionRequest, questionId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((Long)returnObj);
}

public String getHtmlView(long questionId, ThemeDisplay themeDisplay, Document document){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("getHtmlView", long.class, ThemeDisplay.class, Document.class);
        returnObj = clp.invoke(new MethodHandler(method, questionId, themeDisplay, document));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public Element getResults(ActionRequest actionRequest, long questionId){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("getResults", ActionRequest.class, long.class);
        returnObj = clp.invoke(new MethodHandler(method, actionRequest, questionId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((Element)returnObj);
}

public String getHtmlFeedback(Document document,long questionId, long actId, ThemeDisplay themeDisplay){
    Object returnObj = null;

    try {
        Method method = QuestionType.class.getMethod("getHtmlFeedback", Document.class, long.class, long.class, ThemeDisplay.class);
        returnObj = clp.invoke(new MethodHandler(method, document, questionId, actId, themeDisplay));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public void exportQuestionAnswers(PortletDataContext context, Element root, long questionId, LearningActivity activity) throws PortalException, SystemException{

        try {
            ClassLoader classLoader = clp.getClassLoader();
            Class laTypeClass = Class.forName(LearningActivityType.class.getName(),true, classLoader);
            Class laClass = Class.forName(LearningActivity.class.getName(),true, classLoader);
            Object learningActivityObj = translateLearningActivity(activity);

            Method method = laTypeClass.getMethod("exportQuestionAnswers", PortletDataContext.class, Element.class, long.class, laClass);
            clp.invoke(new MethodHandler(method, context, root, questionId, learningActivityObj));
        }
        catch (Throwable t) {
            t = ClpSerializer.translateThrowable(t);

            if (t instanceof RuntimeException) {
                throw (RuntimeException)t;
            }
            else {
                throw new RuntimeException(t.getClass().getName() +
                    " is not a valid exception");
            }
        }

    }

public void importQuestionAnswers(PortletDataContext context, Element entryElement, long questionId, long userId, ServiceContext serviceContext) throws SystemException, PortalException{
    try {
        ClassLoader classLoader = clp.getClassLoader();
        Class laTypeClass = Class.forName(LearningActivityType.class.getName(),true, classLoader);

        Method method = laTypeClass.getMethod("importQuestionAnswers", PortletDataContext.class, Element.class, long.class, long.class, ServiceContext.class);
        clp.invoke(new MethodHandler(method, context, entryElement, questionId, userId, serviceContext));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

}

public void importXML(long actId, Element question, TestAnswerLocalService testAnswerLocalService) throws SystemException, PortalException {

        try {

            ClassLoader classLoader = clp.getClassLoader();
            Class testAnswerLocalServiceClass = Class.forName(TestAnswerLocalService.class.getName(), true, classLoader);

            Method method = QuestionType.class.getMethod("importXML", long.class, Element.class, testAnswerLocalServiceClass);
            clp.invoke(new MethodHandler(method, actId, question, testAnswerLocalService));
        }
        catch (Throwable t) {
            t = ClpSerializer.translateThrowable(t);

            if (t instanceof RuntimeException) {
                throw (RuntimeException)t;
            }
            else {
                throw new RuntimeException(t.getClass().getName() +
                    " is not a valid exception");
            }
        }
    }

public String getTitle(Locale locale){
    Object returnObj = null;

    try {
        MethodKey getTitleMethod = new MethodKey(clp.getClassName(), "getTitle", Locale.class);
        returnObj = clp.invoke(new MethodHandler(getTitleMethod, locale));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String getDescription(Locale locale){
    Object returnObj = null;

    try {
        MethodKey getDescriptionMethod = new MethodKey(clp.getClassName(), "getDescription", Locale.class); 
        returnObj = clp.invoke(new MethodHandler(getDescriptionMethod, locale));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String getSuffix(){
    Object returnObj = null;

    try {
        MethodKey getSuffixMethod = new MethodKey(clp.getClassName(), "getSuffix"); 
        returnObj = clp.invoke(new MethodHandler(getSuffixMethod));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String getSuffix(long groupId){
    Object returnObj = null;

    try {
        MethodKey getSuffixMethod = new MethodKey(clp.getClassName(), "getSuffix"); 
        returnObj = clp.invoke(new MethodHandler(getSuffixMethod));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String translate(Locale locale, double result){
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "translate", Locale.class, double.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, locale, result));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String translate(Locale locale, CourseResult result) {
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "translate", Locale.class, double.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, locale, result));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String translate(Locale locale, LearningActivityResult result) {
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "translate", Locale.class, double.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, locale, result));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String translate(Locale locale, ModuleResult result) {
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "translate", Locale.class, double.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, locale, result));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public String translate(Locale locale, long groupId, double result) {
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "translate", Locale.class, double.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, locale, result));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

@Override
public String getExpecificContentPage() {
    Object returnObj = null;

    try {
        MethodKey getExpecificContentPageMethod = new MethodKey(clp.getClassName(), "getExpecificContentPage", Locale.class); 
        returnObj = clp.invoke(new MethodHandler(getExpecificContentPageMethod));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

@Override
public String getName(Locale locale) {
    Object returnObj = null;

    try {
        MethodKey getNameMethod = new MethodKey(clp.getClassName(), "getName", Locale.class);
        returnObj = clp.invoke(new MethodHandler(getNameMethod, locale));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

@Override
public boolean especificValidations(UploadRequest uploadRequest,PortletResponse portletResponse){
    Object returnObj = null;

    try {
        MethodKey especificValidationsMethod = new MethodKey(clp.getClassName(), "especificValidations", UploadRequest.class, PortletResponse.class);           
        returnObj = clp.invoke(new MethodHandler(especificValidationsMethod, uploadRequest, portletResponse));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            t.printStackTrace();
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
    return ((Boolean)returnObj).booleanValue();     
}

@Override
public long calculateModuleResult(long moduleId, long userId)
        throws SystemException {
    Object returnObj = null;

    try {
        MethodKey especificValidationsMethod = new MethodKey(clp.getClassName(), "calculateModuleResult", long.class, long.class);          
        returnObj = clp.invoke(new MethodHandler(especificValidationsMethod, moduleId, userId));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            t.printStackTrace();
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
    return ((Long)returnObj).longValue();   
}

@Override
public String filter(String description) {
    Object returnObj = null;

    try {
        MethodKey translateMethod = new MethodKey(clp.getClassName(), "filter", String.class); 
        returnObj = clp.invoke(new MethodHandler(translateMethod, description));
    }
    catch (Throwable t) {
        t = ClpSerializer.translateThrowable(t);

        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((String)returnObj);
}

public java.lang.String getBeanIdentifier() {
    Object returnObj = null;

    MethodHandler methodHandler = new MethodHandler(_getBeanIdentifierMethodKey0);

    try {
        returnObj = _classLoaderProxy.invoke(methodHandler);
    } catch (Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return (java.lang.String) ClpSerializer.translateOutput(returnObj);
}

public java.util.List<br.gov.camara.edemocracia.movetopico.model.Topico> getTopicosPorComunidadeEForum(
    long idComunidade, long idForum) {
    Object returnObj = null;

    MethodHandler methodHandler = new MethodHandler(_getTopicosPorComunidadeEForumMethodKey2,
            idComunidade, idForum);

    try {
        returnObj = _classLoaderProxy.invoke(methodHandler);
    } catch (Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return (java.util.List<br.gov.camara.edemocracia.movetopico.model.Topico>) ClpSerializer.translateOutput(returnObj);
}

public java.util.List<com.liferay.portlet.messageboards.model.MBCategory> getForunsComunidade(
    long idComunidade) {
    Object returnObj = null;

    MethodHandler methodHandler = new MethodHandler(_getForunsComunidadeMethodKey3,
            idComunidade);

    try {
        returnObj = _classLoaderProxy.invoke(methodHandler);
    } catch (Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return (java.util.List<com.liferay.portlet.messageboards.model.MBCategory>) ClpSerializer.translateOutput(returnObj);
}

public java.util.List<com.liferay.portal.model.Group> getComunidadesComPermissaoParaMover(
    long idUsuario, long idComunidadeOrigem) {
    Object returnObj = null;

    MethodHandler methodHandler = new MethodHandler(_getComunidadesComPermissaoParaMoverMethodKey4,
            idUsuario, idComunidadeOrigem);

    try {
        returnObj = _classLoaderProxy.invoke(methodHandler);
    } catch (Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return (java.util.List<com.liferay.portal.model.Group>) ClpSerializer.translateOutput(returnObj);
}

public void moveTopico(
    br.gov.camara.edemocracia.movetopico.model.InfoMoverTopico info)
    throws com.liferay.portal.kernel.exception.PortalException,
        com.liferay.portal.kernel.exception.SystemException {
    MethodHandler methodHandler = new MethodHandler(_moveTopicoMethodKey5,
            ClpSerializer.translateInput(info));

    try {
        _classLoaderProxy.invoke(methodHandler);
    } catch (Throwable t) {
        if (t instanceof com.liferay.portal.kernel.exception.PortalException) {
            throw (com.liferay.portal.kernel.exception.PortalException) t;
        }

        if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
            throw (com.liferay.portal.kernel.exception.SystemException) t;
        }

        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }
}

public int getNumberOfInfrastructures() {
    Object returnObj = null;

    MethodHandler methodHandler = new MethodHandler(_getNumberOfInfrastructuresMethodKey0);

    try {
        returnObj = _classLoaderProxy.invoke(methodHandler);
    }
    catch (Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        }
        else {
            throw new RuntimeException(t.getClass().getName() +
                " is not a valid exception");
        }
    }

    return ((Integer)returnObj).intValue();
}