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