X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=nemo-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnemo%2Fuser%2FUserManager.java;fp=nemo-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnemo%2Fuser%2FUserManager.java;h=78f455e8330609eec41e3e9d70db587dd4b8fc98;hb=8308fdd44509c1ae1b5b1841d5f4f6cd2cf33590;hp=5e49698ae29680d2f4becadb0d71a17df26d52e7;hpb=1a7a9878b076f3d6ffff7ac693beb599cbd19cc0;p=nemo.git

diff --git a/nemo-impl/src/main/java/org/opendaylight/nemo/user/UserManager.java b/nemo-impl/src/main/java/org/opendaylight/nemo/user/UserManager.java
index 5e49698..78f455e 100644
--- a/nemo-impl/src/main/java/org/opendaylight/nemo/user/UserManager.java
+++ b/nemo-impl/src/main/java/org/opendaylight/nemo/user/UserManager.java
@@ -7,7 +7,9 @@
  */
 package org.opendaylight.nemo.user;
 
-import com.google.common.util.concurrent.Futures;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.CommonRpcResult.ResultCode.Error; 
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.CommonRpcResult.ResultCode.Ok; 
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
@@ -79,66 +81,63 @@ public class UserManager implements NemoIntentService, AutoCloseable {
 
         rpcRegistration = rpcProviderRegistry.addRpcImplementation(NemoIntentService.class, this);
     }
+
     @Override
     public Future<RpcResult<AdvancedNemoQueryOutput>> advancedNemoQuery(AdvancedNemoQueryInput input) {
-        RpcResult<AdvancedNemoQueryOutput> advancedNemoQueryOutputRpcResult = null;
-        AdvancedNemoQueryOutputBuilder advancedNemoQueryOutputBuilder = new AdvancedNemoQueryOutputBuilder();
+        final AdvancedNemoQueryOutputBuilder outputBuilder = new AdvancedNemoQueryOutputBuilder();
 
         String errorInfo = advancedQuery.advancedQuery(aaa, input);
         if (errorInfo != null)
         {
-            advancedNemoQueryOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+            outputBuilder.setResultCode(Error).setMessage(errorInfo);
         }
         else
         {
-            advancedNemoQueryOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage(advancedQuery.getAdvancedQueryReuslt(input));
+            outputBuilder.setResultCode(Ok).setMessage(advancedQuery.getAdvancedQueryReuslt(input));
         }
-        advancedNemoQueryOutputRpcResult = RpcResultBuilder.<AdvancedNemoQueryOutput>success(advancedNemoQueryOutputBuilder.build()).build();
 
-        return Futures.immediateFuture(advancedNemoQueryOutputRpcResult);
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<BeginTransactionOutput>> beginTransaction(BeginTransactionInput input) {
-        RpcResult<BeginTransactionOutput> beginTransactionOutputResult = null;
-        BeginTransactionOutputBuilder beginTransactionOutputBuilder = new BeginTransactionOutputBuilder();
+        final BeginTransactionOutputBuilder outputBuilder = new BeginTransactionOutputBuilder();
 
         if (transaction)
         {
-            beginTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage("The previous transaction has not been finished.");
+            outputBuilder.setResultCode(Error).setMessage("The previous transaction has not been finished.");
         }
         else
         {
             String errorInfo = transactionBegin.transactionbegin(aaa,input);
             if (errorInfo != null)
             {
-                beginTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+                outputBuilder.setResultCode(Error).setMessage(errorInfo);
             }
             else
             {
                 transaction = true;
-                beginTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("Transaction Begin.");
+                outputBuilder.setResultCode(Ok).setMessage("Transaction Begin.");
             }
         }
-        beginTransactionOutputResult = RpcResultBuilder.<BeginTransactionOutput>success(beginTransactionOutputBuilder.build()).build();
-        return Futures.immediateFuture(beginTransactionOutputResult);
+
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<EndTransactionOutput>> endTransaction(EndTransactionInput input) {
-        RpcResult<EndTransactionOutput> endTransactionOutputResult = null;
-        EndTransactionOutputBuilder endTransactionOutputBuilder = new EndTransactionOutputBuilder();
+        final EndTransactionOutputBuilder outputBuilder = new EndTransactionOutputBuilder();
 
         if (!transaction)
         {
-            endTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage("The transaction has not started.");
+            outputBuilder.setResultCode(Error).setMessage("The transaction has not started.");
         }
         else
         {
             String errorInfo = transactionEnd.transactionend(aaa,input);
             if (errorInfo != null)
             {
-                endTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+                outputBuilder.setResultCode(Error).setMessage(errorInfo);
             }
             else
             {
@@ -149,12 +148,12 @@ public class UserManager implements NemoIntentService, AutoCloseable {
                     try
                     {
                         intentResolver.resolveIntent(input.getUserId());
-						endTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("The transaction ends.");
+                        outputBuilder.setResultCode(Ok).setMessage("The transaction ends.");
                     }
                     catch (IntentResolutionException | VNMappingException e)
                     {
                         e.printStackTrace();
-                        endTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(e.getMessage());
+                        outputBuilder.setResultCode(Error).setMessage(e.getMessage());
                     }
                     catch (Exception e)
                     {
@@ -163,99 +162,88 @@ public class UserManager implements NemoIntentService, AutoCloseable {
                 }
                 else
                 {
-                    endTransactionOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("The transaction ends.");
+                    outputBuilder.setResultCode(Ok).setMessage("The transaction ends.");
                 }
 
             }
         }
-        endTransactionOutputResult = RpcResultBuilder.<EndTransactionOutput>success(endTransactionOutputBuilder.build()).build();
-        return Futures.immediateFuture(endTransactionOutputResult);
+
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<LanguageStyleNemoRequestOutput>> languageStyleNemoRequest(LanguageStyleNemoRequestInput input) {
-        RpcResult<LanguageStyleNemoRequestOutput> styleNemoRequestOutputRpcResult = null;
-        LanguageStyleNemoRequestOutputBuilder languageStyleNemoRequestOutputBuilder = new LanguageStyleNemoRequestOutputBuilder();
+        final LanguageStyleNemoRequestOutputBuilder outputBuilder = new LanguageStyleNemoRequestOutputBuilder();
 
         String errorInfo = languageIntent.LanIntentHandler(aaa,input);
 
         if (errorInfo != null)
         {
-            languageStyleNemoRequestOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+            outputBuilder.setResultCode(Error).setMessage(errorInfo);
         }
         else
         {
-            languageStyleNemoRequestOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("The intent has been stored in this transaction.");
+            outputBuilder.setResultCode(Ok).setMessage("The intent has been stored in this transaction.");
             informresolver = true;
         }
-        styleNemoRequestOutputRpcResult = RpcResultBuilder.<LanguageStyleNemoRequestOutput>success(languageStyleNemoRequestOutputBuilder.build()).build();
 
-        return Futures.immediateFuture(styleNemoRequestOutputRpcResult);
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<RegisterUserOutput>> registerUser(RegisterUserInput input) {
-        RpcResult<RegisterUserOutput> registerUserOutputRpcResult = null;
-        RegisterUserOutputBuilder registerUserOutputBuilder = new RegisterUserOutputBuilder();
+        final RegisterUserOutputBuilder registerUserOutputBuilder = new RegisterUserOutputBuilder();
+
         String errorInfo = registerUser.registerUser(input);
 
         if (errorInfo != null)
         {
-            registerUserOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+            registerUserOutputBuilder.setResultCode(Error).setMessage(errorInfo);
         }
         else
         {
-            registerUserOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("Register user successfully.");
+            registerUserOutputBuilder.setResultCode(Ok).setMessage("Register user successfully.");
         }
 
-        registerUserOutputRpcResult = RpcResultBuilder.<RegisterUserOutput>success(registerUserOutputBuilder.build()).build();
-
-        return Futures.immediateFuture(registerUserOutputRpcResult);
+        return RpcResultBuilder.success(registerUserOutputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<StructureStyleNemoDeleteOutput>> structureStyleNemoDelete(StructureStyleNemoDeleteInput input) {
-        RpcResult<StructureStyleNemoDeleteOutput> styleNemoDeleteOutputRpcResult = null;
-        StructureStyleNemoDeleteOutputBuilder styleNemoDeleteOutputBuilder = new StructureStyleNemoDeleteOutputBuilder();
+        final StructureStyleNemoDeleteOutputBuilder outputBuilder = new StructureStyleNemoDeleteOutputBuilder();
 
         String errorInfo = deleteIntent.styleNemoDeleteOutput(aaa,input);
 
         if (errorInfo != null)
         {
-            styleNemoDeleteOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(errorInfo);
+            outputBuilder.setResultCode(Error).setMessage(errorInfo);
         }
         else
         {
-            styleNemoDeleteOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("The intent has been handled by user manager successfully.");
+            outputBuilder.setResultCode(Ok).setMessage("The intent has been handled by user manager successfully.");
             informresolver = true;
         }
 
-
-        styleNemoDeleteOutputRpcResult = RpcResultBuilder.<StructureStyleNemoDeleteOutput>success(styleNemoDeleteOutputBuilder.build()).build();
-
-        return Futures.immediateFuture(styleNemoDeleteOutputRpcResult);
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override
     public Future<RpcResult<StructureStyleNemoUpdateOutput>> structureStyleNemoUpdate(StructureStyleNemoUpdateInput input) {
-        RpcResult<StructureStyleNemoUpdateOutput> styleNemoUpdateOutputRpcResult = null;
-        StructureStyleNemoUpdateOutputBuilder styleNemoUpdateOutputBuilder = new StructureStyleNemoUpdateOutputBuilder();
+        final StructureStyleNemoUpdateOutputBuilder outputBuilder = new StructureStyleNemoUpdateOutputBuilder();
 
         String erroInfo = updateIntent.updateIntent(aaa,input);
 
         if (erroInfo != null)
         {
-            styleNemoUpdateOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Error).setMessage(erroInfo);
+            outputBuilder.setResultCode(Error).setMessage(erroInfo);
         }
         else
         {
-            styleNemoUpdateOutputBuilder.setResultCode(CommonRpcResult.ResultCode.Ok).setMessage("The intent has been handled by user manager successfully.");
+            outputBuilder.setResultCode(Ok).setMessage("The intent has been handled by user manager successfully.");
             informresolver = true;
         }
 
-        styleNemoUpdateOutputRpcResult = RpcResultBuilder.<StructureStyleNemoUpdateOutput>success(styleNemoUpdateOutputBuilder.build()).build();
-
-        return Futures.immediateFuture(styleNemoUpdateOutputRpcResult);
+        return RpcResultBuilder.success(outputBuilder).buildFuture();
     }
 
     @Override