1: package com.aimms.aimmssdk.examples.callback;
  2: 
  3: import com.aimms.aimmssdk.*;
  4: import java.util.ArrayList;
  5: import org.slf4j.Logger;
  6: import org.slf4j.LoggerFactory;
  7: 
  8: /**
  9:  * This example demonstrates the custom handling of errors. It overrides the
 10:  * default behavior in which AimmsExceptions are thrown in all error cases in
 11:  * two ways: The LoggingCallback logs all minor errors, and keeps throwing the
 12:  * severe ones The DebuggingCallback logs as well, and asserts where errors can
 13:  * only be expected if the model was called erroneously.
 14:  */
 15: class Callback {
 16: 
 17:     static private Logger logger = LoggerFactory.getLogger(Callback.class);
 18: 
 19:     static class LoggingCallback implements ICallBack {
 20: 
 21:         public void onMessages(ArrayList<AimmsMessage> messages) {
 22:             // Overridden behavior:
 23:             // Only throw if an error is caused by the communication layer or the AIMMS model. 
 24:             // Log the message in other cases. 
 25: 
 26:             for (int m = 0; m < messages.size(); ++m) {
 27:                 AimmsMessage msg = messages.get(m);
 28:                 switch (msg.code) {
 29:                     case AM_Info:
 30:                         logger.info(msg.message);
 31:                         break;
 32:                     case AM_Warning:
 33:                         logger.warn(msg.message);
 34:                         break;
 35:                     case AM_InvalidUse:
 36:                         logger.error("InvalidUse: {}", msg.message);
 37:                         break;
 38:                     case AM_Runtime:
 39:                         logger.error("Runtime: {}", msg.message);
 40:                         break;
 41:                     case AM_License:
 42:                         throw new AimmsLicenseException(msg.message);
 43:                     case AM_Communication:
 44:                         throw new AimmsCommunicationException(msg.message);
 45:                     case AM_General:  // AIMMS Model errors
 46:                         throw new AimmsException(msg.code, msg.message);
 47:                     default:
 48:                         throw new AimmsException(msg.code, msg.message);
 49:                 }
 50: 
 51:                 // The rationale behind this distinction is that in the cases in which exceptions are thrown now, 
 52:                 // the state of the data is not known. For example: if during the flush of the buffers an error on 
 53:                 // a specific value is detected by the AIMMS model, it is not known which part of the remaining data 
 54:                 // is already written to the model. 
 55:             }
 56:         }
 57:     }
 58: 
 59:     static class DebuggingCallback implements ICallBack {
 60: 
 61: 
 62:     public void onMessages(ArrayList<AimmsMessage> messages) {
 63:         // Overridden behavior:
 64:         // 
 65:         //  assert whether an AM_InvalidUse is encountered, because that is an indication of a bug. 
 66:         //
 67:         // For example: adding a string to a numerical parameter gives AM_InvalidUse. 
 68: 
 69: 
 70:         for (int m = 0; m < messages.size(); ++m) {
 71:             AimmsMessage msg = messages.get(m);
 72: 
 73:             switch (msg.code) {
 74:                 case AM_InvalidUse:
 75:                     logger.error(msg.message);
 76:                     assert (false);
 77:                     break;
 78:                 default:
 79:                     logger.error("{}:{}", msg.code, msg.message);
 80:                     break;
 81:             }
 82: 
 83:         }
 84:     }
 85: }
 86:     
 87:     
 88:     
 89:     public static void run(ISession session) {
 90:         LoggingCallback cb = new LoggingCallback();
 91:         //Attach the custom Callback to the session.
 92:         session.setCallBack(cb);
 93: 
 94:         //To illustrate the behavior of our callback, make some mistakes:
 95: 
 96:         //Try to retrieve the set Locations as a multidimensional parameter.
 97:         //This is an InvalidUse error: 
 98:         //   LoggingCallback will not throw
 99:         //   DebuggingCallback will assert here. 
100:         IMultiDimData parameterLocations = session.openMultiDim("Locations");
101: 
102:         if (parameterLocations == null) {
103:             logger.error("Expected an InvalidUse error!");
104:         }
105: 
106:         IMultiDimData parameterSupply = session.openMultiDim("Supply");
107:         //Do not forget to check the result if the callback does not throw on each error!
108:         if (parameterSupply == null) {
109:             logger.error("Did not expect an error here!");
110:         } else {
111:             // Since we did not add any depots, we will get a runtime error here:
112:             parameterSupply.setValue(new Tuple("London"), 20.0);
113: 
114:             // Using "insert" will resolve this error, since it adds London to the index domain of Supply if not existing. 
115:             parameterSupply.insert(new Tuple("London"), 20.0);
116: 
117:             // Supply is a numeric parameter: it will not allow strings as value:
118:             // DebuggingCallback will assert.
119:             parameterSupply.insert(new Tuple("Paris"), "thirty");
120:         }
121: 
122:         IMultiDimData parameterDemand = session.openMultiDim("Demand");
123: 
124:         if (parameterDemand == null) {
125:             logger.error("Did not expect an error here!");
126:         } else {
127:             ITuple tup = parameterDemand.createTuple();
128: 
129:             // "London" exists in the set Locations (because we added it to Depots by inserting in Supply),
130:             // but the index domain of Demand is Customers, which  is still empty.
131:             // The nocheck_ functions are less expensive because they do not check this in advance.
132:             // Cout will not show an error after these actions:
133:             tup.getElement(0).nocheck_setLabel("London");
134:             parameterDemand.setValue(tup, 90);
135:             tup.close();
136: 
137:             // But this performance improvement comes with a downside:
138:             try {
139:                 // The mistake will become apparent when the data is sent to the model. 
140:                 // Then it is undetermined wether the inserted value for "London" in Supply is indeed inserted in Aimms.
141:                 // If Londen is added to the domainset and this set is flushed before the Supply is flushed,
142:                 // the Supply of Londen will be set to its new value without an error.
143:                 // If Londen is not added or Supply is flushed earlier (which may be due to an internal flush),
144:                 // then an error will occur and even other buffered modifications to Supply may not have been inserted in Aimms.
145:                 session.updateData();
146: 
147:             } catch (AimmsException e) {
148:                 logger.error(e.getMessage());
149:             }
150: 
151:             parameterSupply.close();
152:             parameterDemand.close();
153:         }
154:     }
155: }