/// <summary> /// Recursively load data into the tuple current being loaded. /// </summary> /// <param name="handler">The handler constructing the current element.</param> /// <param name="schema">Schema of tuple being constructed.</param> /// <param name="row">Data source for tuple to construct.</param> /// <param name="absIndex">Absolute index into <code>row</code> for the next column to process.</param> /// <returns>The updated absolute index.</returns> private int fillTuple(OplDataHandler handler, ITupleSchema schema, IRow row, int absIndex) { handler.StartTuple(); for (int i = 0; i < schema.Size; ++i) { if (schema.IsTuple(i)) { ILOG.Opl_Core.Cppimpl.IloTupleSchema s = (ILOG.Opl_Core.Cppimpl.IloTupleSchema)schema; absIndex = fillTuple(handler, s.getTupleColumn(i), row, absIndex); continue; } if (schema.IsNum(i)) { SET_FLOAT(handler, row, absIndex); } else if (schema.IsInt(i)) { SET_INT(handler, row, absIndex); } else if (schema.IsSymbol(i)) { SET_STRING(handler, row, absIndex); } else { throw new NotImplementedException("tuple element type not supported"); } ++absIndex; } handler.EndTuple(); return(absIndex); }
private void GetCostWeights(OplDataHandler handler) { // initialize the tuple set 'CostFunctionWeights' handler.StartElement("CostFunctionWeights"); handler.StartSet(); // Add tuple handler.StartTuple(); handler.AddStringItem("a"); handler.AddNumItem(LithographyArea.WeightA); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddStringItem("b"); handler.AddNumItem(LithographyArea.WeightB); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddStringItem("c"); handler.AddNumItem(LithographyArea.WeightC); handler.EndTuple(); handler.EndSet(); handler.EndElement(); }
/// <summary> /// Reads a table and inject it as a tuple set in OPL. /// </summary> /// <param name="name">The name of the Data Set</param> /// <param name="reader">The SqlDataReader to read from</param> private void ReadTupleSet(String name, DbDataReader reader) { OplDataHandler handler = DataHandler; OplElement element = handler.getElement(name); ITupleSchema schema = element.AsTupleSet().Schema; int size = schema.Size; String[] oplFieldsName = new String[size]; OplElementDefinitionType.Type[] oplFieldsType = new OplElementDefinitionType.Type[size]; this.FillNamesAndTypes(schema, oplFieldsName, oplFieldsType); handler.StartElement(name); handler.StartSet(); while (reader.Read()) { handler.StartTuple(); for (int column = 0; column < oplFieldsName.Length; column++) { String columnName = oplFieldsName[column]; HandleColumnValue(handler, oplFieldsType[column], reader[columnName]); } handler.EndTuple(); } handler.EndSet(); }
/// <summary> /// Load an element that is just a value. /// </summary> private void loadPrimitive(OplDataHandler handler, string name, IEnumerator <IRow> rows, Action <OplDataHandler, IRow, int> setValue) { handler.StartElement(name); rows.MoveNext(); setValue(handler, rows.Current, 0); handler.EndElement(); }
public override void CustomRead() { OplDataHandler handler = DataHandler; // Get the element of the predefined name. // If no such element is defined then exit early. // The element must be either a tuple or a set of tuples. // Any custom load specification specified by the element is then processed. OplElement spec = handler.getElement(ELEM_NAME); if (spec == null) { return; } if (spec.ElementType == OplElementType.Type.TUPLE) { loadSpec(handler, spec.AsTuple()); } else if (spec.ElementType == OplElementType.Type.SET_TUPLE) { foreach (ITuple tuple in spec.AsTupleSet()) { loadSpec(handler, tuple); } } else { throw new NotImplementedException(ELEM_NAME + " must be (set of) tuple"); } }
private void GetOrders(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("Orders"); handler.StartSet(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); bool eligible = false; // Check if elible on any machine (not Down) foreach (Machine machine in LithographyArea.Machines) { // Check if machine is Down if (LithographyArea.MachineStates[machine.Name] == "Down") { continue; } // Get needed recipe for the lot string recipe = CPDispatcher.GetRecipe(peekLot, machine); string recipeKey = machine.Name + "__" + recipe; // Check if needed recipe is eligible on machine bool recipeEligible = CPDispatcher.CheckMachineEligibility(recipeKey); // Check if processingTime is known bool processingTimeKnown = CPDispatcher.CheckProcessingTimeKnown(peekLot, machine, recipe); if (recipeEligible && processingTimeKnown) { eligible = true; break; } } if (eligible) { // Add tuple handler.StartTuple(); handler.AddStringItem(peekLot.Id.ToString()); //handler.AddStringItem(peekLot.Id.ToString()); handler.AddIntItem(ProductNameToID[peekLot.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(peekLot.LotQty); handler.AddNumItem(CPDispatcher.GetDueDateWeight(peekLot)); handler.AddNumItem(CPDispatcher.GetWIPBalanceWeight(peekLot)); handler.EndTuple(); } } handler.EndSet(); handler.EndElement(); }
public override void CustomRead() { int _nbConfs = 7; int _nbOptions = 5; OplDataHandler handler = getDataHandler(); handler.StartElement("nbConfs"); handler.AddIntItem(_nbConfs); handler.EndElement(); handler.StartElement("nbOptions"); handler.AddIntItem(_nbOptions); handler.EndElement(); int[] _demand = { 5, 5, 10, 10, 10, 10, 5 }; handler.StartElement("demand"); handler.StartArray(); for (int i = 0; i < _nbConfs; i++) { handler.AddIntItem(_demand[i]); } handler.EndArray(); handler.EndElement(); int[,] _option = { { 1, 0, 0, 0, 1, 1, 0 }, { 0, 0, 1, 1, 0, 1, 0 }, { 1, 0, 0, 0, 1, 0, 0 }, { 1, 1, 0, 1, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0 } }; handler.StartElement("option"); handler.StartArray(); for (int i = 0; i < _nbOptions; i++) { handler.StartArray(); for (int j = 0; j < _nbConfs; j++) { handler.AddIntItem(_option[i, j]); } handler.EndArray(); } handler.EndArray(); handler.EndElement(); int[,] _capacity = { { 1, 2 }, { 2, 3 }, { 1, 3 }, { 2, 5 }, { 1, 5 } }; handler.StartElement("capacity"); handler.StartArray(); for (int i = 0; i < _nbOptions; i++) { handler.StartTuple(); for (int j = 0; j <= 1; j++) { handler.AddIntItem(_capacity[i, j]); } handler.EndTuple(); } handler.EndArray(); handler.EndElement(); }
/// <summary> /// Load an element that is a plain tuple. /// </summary> private void loadTuple(OplDataHandler handler, string name, IEnumerator <IRow> rows) { OplElement elem = handler.getElement(name); ITuple tuple = elem.AsTuple(); handler.StartElement(name); rows.MoveNext(); fillTuple(handler, tuple.Schema, rows.Current, 0); handler.EndElement(); }
/// <summary> /// Load a collection of tuples types. /// </summary> private void loadTupleCollection(OplDataHandler handler, string name, IEnumerator <IRow> rows, ITupleSchema schema, Action <OplDataHandler> startCollection, Action <OplDataHandler> endCollection) { handler.StartElement(name); startCollection(handler); while (rows.MoveNext()) { fillTuple(handler, schema, rows.Current, 0); } endCollection(handler); handler.EndElement(); }
/// <summary> /// Load a collection or array of primitive types. /// </summary> private void loadPrimitiveCollection(OplDataHandler handler, string name, IEnumerator <IRow> rows, Action <OplDataHandler> startCollection, Action <OplDataHandler> endCollection, Action <OplDataHandler, IRow, int> setValue) { handler.StartElement(name); startCollection(handler); while (rows.MoveNext()) { setValue(handler, rows.Current, 0); } endCollection(handler); handler.EndElement(); }
private void GetProductAuxResources(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("ProductAuxResources"); handler.StartSet(); List <Lot> allLots = new List <Lot>(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); allLots.Add(peekLot); } foreach (Machine machine in LithographyArea.Machines) { if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); allLots.Add(lotAtMachine); } } List <string> productNames = new List <string>(); // Loop through queue foreach (Lot lot in allLots) { string productName = lot.MasksetLayer_RecipeStepCluster; if (!productNames.Contains(productName)) { // Add tuple handler.StartTuple(); handler.AddIntItem(ProductNameToID[productName]); handler.AddStringItem(lot.ReticleID1); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddIntItem(ProductNameToID[productName]); handler.AddStringItem(lot.IrdName); handler.EndTuple(); productNames.Add(productName); } } handler.EndSet(); handler.EndElement(); }
public override void CustomRead() { int _nbOrders = 12; int _nbSlabs = 12; int _nbColors = 8; int _nbCap = 20; OplDataHandler handler = getDataHandler(); handler.StartElement("nbOrders"); handler.AddIntItem(_nbOrders); handler.EndElement(); handler.StartElement("nbSlabs"); handler.AddIntItem(_nbSlabs); handler.EndElement(); handler.StartElement("nbColors"); handler.AddIntItem(_nbColors); handler.EndElement(); handler.StartElement("nbCap"); handler.AddIntItem(_nbCap); handler.EndElement(); int[] _capacity = { 0, 11, 13, 16, 17, 19, 20, 23, 24, 25, 26, 27, 28, 29, 30, 33, 34, 40, 43, 45 }; handler.StartElement("capacities"); handler.StartArray(); for (int i = 0; i < _nbCap; i++) { handler.AddIntItem(_capacity[i]); } handler.EndArray(); handler.EndElement(); int[] _weight = { 22, 9, 9, 8, 8, 6, 5, 3, 3, 3, 2, 2 }; handler.StartElement("weight"); handler.StartArray(); for (int i = 0; i < _nbOrders; i++) { handler.AddIntItem(_weight[i]); } handler.EndArray(); handler.EndElement(); int[] _colors = { 5, 3, 4, 5, 7, 3, 6, 0, 2, 3, 1, 5 }; handler.StartElement("colors"); handler.StartArray(); for (int i = 0; i < _nbOrders; i++) { handler.AddIntItem(_colors[i]); } handler.EndArray(); handler.EndElement(); }
private void GetProductIDs(OplDataHandler handler) { ProductNameToID = new Dictionary <string, int>(); // initialize the tuple set 'Products' handler.StartElement("Products"); handler.StartSet(); List <Lot> allLots = new List <Lot>(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); allLots.Add(peekLot); } foreach (Machine machine in LithographyArea.Machines) { if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); allLots.Add(lotAtMachine); } } int productID = 0; // Loop through queue foreach (Lot lot in allLots) { string productName = lot.MasksetLayer_RecipeStepCluster; if (!ProductNameToID.ContainsKey(productName)) { // Add tuple handler.StartTuple(); handler.AddIntItem(productID); handler.AddStringItem(productName); handler.EndTuple(); ProductNameToID.Add(productName, productID); productID += 1; } } handler.EndSet(); handler.EndElement(); }
public override void CustomRead() { OplDataHandler handler = DataHandler; GetComputationalSettings(handler); GetCostWeights(handler); GetProductIDs(handler); GetOrders(handler); GetResources(handler); GetAuxResources(handler); GetProductAuxResources(handler); GetModes(handler); GetSetups(handler); }
/// <summary> /// Reads a table and inject the value as a Set in OPL. /// </summary> /// <param name="type">The type of the Set elements</param> /// <param name="name">The name of the Set</param> /// <param name="reader">The SqlDataReader to read from</param> private void ReadSet(OplElementDefinitionType.Type type, String name, DbDataReader reader) { OplDataHandler handler = DataHandler; handler.StartElement(name); handler.StartSet(); while (reader.Read()) { HandleColumnValue(handler, type, reader.GetValue(0)); } handler.EndSet(); }
/// <summary> /// Add a new item (field) to the Set currently in the Data handler. /// /// The value of the field is converted and added depending on fieldType. /// </summary> /// <param name="handler">The OPL data handler</param> /// <param name="fieldType">The type of the field to add</param> /// <param name="value">The value to convert</param> private void HandleColumnValue(OplDataHandler handler, OplElementDefinitionType.Type fieldType, object value) { if (fieldType == OplElementDefinitionType.Type.INTEGER) { handler.AddIntItem(Convert.ToInt32(value)); } else if (fieldType == OplElementDefinitionType.Type.FLOAT) { handler.AddNumItem(Convert.ToDouble(value)); } else if (fieldType == OplElementDefinitionType.Type.STRING) { handler.AddStringItem(Convert.ToString(value)); } }
private void GetComputationalSettings(OplDataHandler handler) { // initialize the tuple set handler.StartElement("ComputationalSettings"); handler.StartSet(); // Add tuple handler.StartTuple(); handler.AddStringItem("timeLimit"); handler.AddIntItem(CPDispatcher.TimeLimit); handler.EndTuple(); handler.EndSet(); handler.EndElement(); }
/// <summary> /// Overrides the CustomRead() method in the CustomOplDataSource. /// /// This is the method called for populating the tables when opl.Generate() is called. /// </summary> public override void CustomRead() { OplDataHandler handler = DataHandler; using (DbConnection con = DbUtils.CreateConnection(this.configuration)) { con.Open(); // read queries foreach (KeyValuePair <string, string> query in this.configuration.ReadQueries) { Console.WriteLine("Reading table " + query.Key + " with query " + query.Value); DbCommand command = con.CreateCommand(); command.CommandText = query.Value; using (DbDataReader reader = command.ExecuteReader()) { this.ReadSetOrTuple(query.Key, reader); } } } }
public override void CustomRead() { OplDataHandler handler = DataHandler; handler.StartElement("nbWarehouses"); handler.AddIntItem(_nbWarehouses); handler.EndElement(); handler.StartElement("nbStores"); handler.AddIntItem(_nbStores); handler.EndElement(); handler.StartElement("fixed"); handler.AddIntItem(_fixed); handler.EndElement(); handler.StartElement("disaggregate"); handler.AddIntItem(_disaggregate); handler.EndElement(); }
private void GetAuxResources(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("AuxResources"); handler.StartSet(); List <Lot> allLots = new List <Lot>(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); allLots.Add(peekLot); } foreach (Machine machine in LithographyArea.Machines) { if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); allLots.Add(lotAtMachine); } } // Get Reticles List <string> allReticles = new List <string>(); // Loop through queue foreach (Lot lot in allLots) { if (!allReticles.Contains(lot.ReticleID1)) { if (lot.ReticleID1 == "4106") { // Add tuple handler.StartTuple(); handler.AddStringItem(lot.ReticleID1); handler.AddIntItem(2); handler.EndTuple(); } else { // Add tuple handler.StartTuple(); handler.AddStringItem(lot.ReticleID1); handler.AddIntItem(1); handler.EndTuple(); } allReticles.Add(lot.ReticleID1); } } // Get IRDNames List <string> allIRDNames = new List <string>(); // Loop through queue foreach (Lot lot in allLots) { if (!allIRDNames.Contains(lot.IrdName)) { // Add tuple handler.StartTuple(); handler.AddStringItem(lot.IrdName); int capacity = 2; if (CPDispatcher.AvailableResources.ContainsKey(lot.IrdName)) { capacity = CPDispatcher.AvailableResources[lot.IrdName]; } handler.AddIntItem(capacity); handler.EndTuple(); allIRDNames.Add(lot.IrdName); } } handler.EndSet(); handler.EndElement(); }
private void GetSetups(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("Setups"); handler.StartSet(); List <Lot> allLots = new List <Lot>(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); allLots.Add(peekLot); } foreach (Machine machine in LithographyArea.Machines) { if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); allLots.Add(lotAtMachine); } } List <string> productNamesFrom = new List <string>(); // Loop through queue foreach (Lot lotFrom in allLots) { if (!productNamesFrom.Contains(lotFrom.MasksetLayer_RecipeStepCluster)) { List <string> productNamesTo = new List <string>(); // Loop through queue foreach (Lot lotTo in allLots) { if (!productNamesTo.Contains(lotTo.MasksetLayer_RecipeStepCluster)) { if (lotFrom.ReticleID1 == lotTo.ReticleID1) { // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_ARMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesARMS["SameReticle"]); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_RMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesRMS["SameReticle"]); handler.EndTuple(); } else if (lotFrom.ReticleID1 != lotTo.ReticleID1 && lotFrom.IrdName == lotTo.IrdName) { // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_ARMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesARMS["DifferentReticle"]); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_RMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesRMS["DifferentReticle"]); handler.EndTuple(); } else { // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_ARMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesARMS["DifferentIRD"]); handler.EndTuple(); // Add tuple handler.StartTuple(); handler.AddStringItem("MTRX_RMS"); handler.AddIntItem(ProductNameToID[lotFrom.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(ProductNameToID[lotTo.MasksetLayer_RecipeStepCluster]); handler.AddIntItem((int)LithographyArea.DeterministicNonProductiveTimesRMS["DifferentIRD"]); handler.EndTuple(); } productNamesTo.Add(lotTo.MasksetLayer_RecipeStepCluster); } } productNamesFrom.Add(lotFrom.MasksetLayer_RecipeStepCluster); } } handler.EndSet(); handler.EndElement(); }
private void GetModes(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("Modes"); handler.StartSet(); List <Lot> allLots = new List <Lot>(); // Loop through queue for (int i = 0; i < Queue.Length; i++) { // Peek next lot in queue Lot peekLot = Queue.PeekAt(i); allLots.Add(peekLot); } foreach (Machine machine in LithographyArea.Machines) { if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); allLots.Add(lotAtMachine); } } List <string> productNames = new List <string>(); // Loop through queue foreach (Lot lot in allLots) { if (!productNames.Contains(lot.MasksetLayer_RecipeStepCluster)) { int modeNr = 0; foreach (Machine machine in LithographyArea.Machines) { // Check if machine is Down if (LithographyArea.MachineStates[machine.Name] == "Down") { continue; } // Get needed recipe for the lot string recipe = CPDispatcher.GetRecipe(lot, machine); string recipeKey = machine.Name + "__" + recipe; // Check if needed recipe is eligible on machine bool recipeEligible = CPDispatcher.CheckMachineEligibility(recipeKey); // Check if processingTime is known bool processingTimeKnown = CPDispatcher.CheckProcessingTimeKnown(lot, machine, recipe); if (recipeEligible && processingTimeKnown) { int?processingTime = null; processingTime = (int)machine.GetDeterministicProcessingTimeFullLot(lot); // Add tuple handler.StartTuple(); handler.AddIntItem(ProductNameToID[lot.MasksetLayer_RecipeStepCluster]); handler.AddIntItem(modeNr); handler.AddStringItem(machine.Name); handler.AddIntItem((int)processingTime); handler.EndTuple(); modeNr += 1; } } productNames.Add(lot.MasksetLayer_RecipeStepCluster); } } handler.EndSet(); handler.EndElement(); }
public override void CustomRead() { OplDataHandler handler = DataHandler; // initialize the int 'simpleInt' handler.StartElement("anInt"); handler.AddIntItem(3); handler.EndElement(); // initialize the int array 'simpleIntArray' handler.StartElement("anIntArray"); handler.StartArray(); handler.AddIntItem(1); handler.AddIntItem(2); handler.AddIntItem(3); handler.EndArray(); handler.EndElement(); // initialize int array indexed by float 'anArrayIndexedByFloat' handler.StartElement("anArrayIndexedByFloat"); handler.StartIndexedArray(); handler.SetItemNumIndex(2.0); handler.AddIntItem(1); handler.SetItemNumIndex(2.5); handler.AddIntItem(2); handler.SetItemNumIndex(1.0); handler.AddIntItem(3); handler.SetItemNumIndex(1.5); handler.AddIntItem(4); handler.EndIndexedArray(); handler.EndElement(); // initialize int array indexed by string 'anArrayIndexedByString' handler.StartElement("anArrayIndexedByString"); handler.StartIndexedArray(); handler.SetItemStringIndex("idx1"); handler.AddIntItem(1); handler.SetItemStringIndex("idx2"); handler.AddIntItem(2); handler.EndIndexedArray(); handler.EndElement(); // initialize a tuple in the order the components are declared handler.StartElement("aTuple"); handler.StartTuple(); handler.AddIntItem(1); handler.AddNumItem(2.3); handler.AddStringItem("not named tuple"); handler.EndTuple(); handler.EndElement(); // initialize a tuple using tuple component names. handler.StartElement("aNamedTuple"); handler.StartNamedTuple(); handler.SetItemName("f"); handler.AddNumItem(3.45); handler.SetItemName("s"); handler.AddStringItem("named tuple"); handler.SetItemName("i"); handler.AddIntItem(99); handler.EndNamedTuple(); handler.EndElement(); // initialize the tuple set 'simpleTupleSet' handler.StartElement("aTupleSet"); handler.StartSet(); // first tuple handler.StartTuple(); handler.AddIntItem(1); handler.AddNumItem(2.5); handler.AddStringItem("a"); handler.EndTuple(); // second element handler.StartTuple(); handler.AddIntItem(3); handler.AddNumItem(4.1); handler.AddStringItem("b"); handler.EndTuple(); handler.EndSet(); handler.EndElement(); // initialize element 3 and 2 of the tuple array 'simpleTupleArray' in that particular order handler.StartElement("aTupleArray"); handler.StartIndexedArray(); // initialize 3rd cell handler.SetItemIntIndex(3); handler.StartTuple(); handler.AddIntItem(1); handler.AddNumItem(2.5); handler.AddStringItem("a"); handler.EndTuple(); // initialize second cell handler.SetItemIntIndex(2); handler.StartTuple(); handler.AddIntItem(3); handler.AddNumItem(4.1); handler.AddStringItem("b"); handler.EndTuple(); handler.EndIndexedArray(); handler.EndElement(); // initialize int array indexed by tuple set 'anArrayIndexedByTuple' handler.StartElement("anArrayIndexedByTuple"); handler.StartIndexedArray(); handler.StartItemTupleIndex(); handler.AddIntItem(3); handler.AddNumItem(4.1); handler.AddStringItem("b"); handler.EndItemTupleIndex(); handler.AddIntItem(1); handler.EndIndexedArray(); handler.EndElement(); // initialize a 2-dimension int array 'a2DIntArray' handler.StartElement("a2DIntArray"); handler.StartArray(); for (int i = 1; i <= 2; i++) { handler.StartArray(); for (int j = 1; j <= 3; j++) { handler.AddIntItem(i * 10 + j); } handler.EndArray(); } handler.EndArray(); handler.EndElement(); }
public override void CustomRead() { int beginTime = 1920; //need to initialized int endTime = 2100; //need to initialized String marketCity = "SHA"; //need to initialized /* * 1* FlightCode:{"1033538119", "1033538066"} * 2* FlightInfo:[<"738","D",1323,1800,0>,<"738","D",1341,1800,0>] * 3* StandCode:{"301","302"} * 4* StandInfo:[<"N",2>,<"N",2>] * 5* Stnd_fl_type:[0,1...] * 6* preflightcode:{"1033538119", "1033538066"} * 7* prestnd: * 8* SCAdjCon:[<"N207","N207L">,<"N207","N207R">,<"N206","N206L">] */ OplDataHandler handler = getDataHandler(); //1.FlightCode handler.StartElement("FlightCode"); handler.StartSet(); List <FlightInfo> FlightCode = new List <FlightInfo>(); for (int i = 0; i < FlightCode.Count; i++) { handler.AddStringItem(FlightCode[i].flightCode); } handler.EndSet(); handler.EndElement(); //2.FlightInfo handler.StartElement("FlightInfo"); handler.StartSet(); List <FlightInfo> FlightInfo = new List <FlightInfo>(); for (int i = 0; i < FlightInfo.Count; i++) { handler.StartTuple(); handler.AddStringItem(FlightInfo[i].flightType); handler.AddStringItem(FlightInfo[i].d_or_i); handler.AddIntItem(int.Parse(FlightInfo[i].startTime));//是否要转为int??居飞 handler.AddIntItem(int.Parse(FlightInfo[i].endTime)); handler.AddIntItem(int.Parse(FlightInfo[i].isTurnArround)); handler.EndTuple(); } handler.EndSet(); handler.EndElement(); //3.StandCode handler.StartElement("StandCode"); handler.StartSet(); List <StandInfo> StandCode = new List <StandInfo>(); for (int i = 0; i < StandCode.Count; i++) { handler.AddStringItem(StandCode[i].standCode); } handler.EndSet(); handler.EndElement(); //4.StandInfo handler.StartElement("StandInfo"); handler.StartSet(); List <StandInfo> StandInfo = new List <StandInfo>(); for (int i = 0; i < StandInfo.Count; i++) { handler.StartTuple(); handler.AddStringItem(StandInfo[i].near_or_far); handler.AddIntItem(int.Parse(StandInfo[i].priority)); handler.EndTuple(); } handler.EndSet(); handler.EndElement(); //5.Stnd_fl_type handler.StartElement("Stnd_fl_type"); handler.StartSet(); //6.preflightcode handler.StartElement("preflightcode"); handler.StartSet(); //7.prestnd handler.StartElement("prestnd"); handler.StartSet(); //8.SCAdjCon handler.StartElement("SCAdjCon"); handler.StartSet(); Console.WriteLine("Read Over"); }
/// <summary> /// Process one load specification. /// </summary> /// <param name="handler">The data loader that constructs OPL elements.</param> /// <param name="tuple">The load specification.</param> private void loadSpec(OplDataHandler handler, ITuple tuple) { // Get the connection string // In the SimpleData implementation we don't use that string. // If you create a data source that is backed up by a file or // by a database, then this string can be used to specify // locations and/or credentials. string connection = tuple.GetStringValue(CONN_FIELD); connection = Interpolate(connection, handler); string connectionType = tryLoadField(tuple, TYPE_FIELD, "SimpleData"); connectionType = Interpolate(connectionType, handler); IDataProvider provider = null; if (connectionType.Equals("SimpleData")) { provider = new SimpleData(connection); } else if (connectionType.Equals("SQLite")) { provider = new SQLiteData(connection); } else { provider = new GenericData(connectionType, connection); } // Process each of load specifications and load the respective // element. using (provider) { ISymbolSet data = tuple.GetSymbolSetValue(DATA_FIELD); IEnumerator e = data.GetEnumerator(); while (e.MoveNext()) { // Split specification into element name and // initialiation string (statement). string s = Interpolate(e.Current.ToString().Trim(), handler); int eq = s.IndexOf('='); string name = s.Substring(0, eq).Trim(); string stmt = s.Substring(eq + 1).Trim(); // Inspect the type of the element and populate it. OplElement elem = handler.getElement(name); OplElementType.Type type = elem.ElementType; using (IEnumerator <IRow> rows = provider.getRows(stmt)) { // (collections of) integers if (type == OplElementType.Type.INT) { loadPrimitive(handler, name, rows, SET_INT); } else if (type == OplElementType.Type.SET_INT) { loadPrimitiveCollection(handler, name, rows, START_SET, END_SET, SET_INT); } else if (type == OplElementType.Type.MAP_INT) { loadPrimitiveCollection(handler, name, rows, START_ARRAY, END_ARRAY, SET_INT); } // (collections of) floating point values else if (type == OplElementType.Type.NUM) { loadPrimitive(handler, name, rows, SET_FLOAT); } else if (type == OplElementType.Type.SET_NUM) { loadPrimitiveCollection(handler, name, rows, START_SET, END_SET, SET_FLOAT); } else if (type == OplElementType.Type.MAP_NUM) { loadPrimitiveCollection(handler, name, rows, START_ARRAY, END_ARRAY, SET_FLOAT); } // (collections of) tuples else if (type == OplElementType.Type.STRING) { loadPrimitive(handler, name, rows, SET_STRING); } else if (type == OplElementType.Type.SET_SYMBOL) { loadPrimitiveCollection(handler, name, rows, START_SET, END_SET, SET_STRING); } else if (type == OplElementType.Type.MAP_SYMBOL) { loadPrimitiveCollection(handler, name, rows, START_ARRAY, END_ARRAY, SET_STRING); } else if (type == OplElementType.Type.TUPLE) { loadTuple(handler, name, rows); } else if (type == OplElementType.Type.SET_TUPLE) { loadTupleCollection(handler, name, rows, elem.AsTupleSet().Schema, START_SET, END_SET); } else if (type == OplElementType.Type.MAP_TUPLE) { loadTupleCollection(handler, name, rows, elem.AsTupleMap().Schema, START_ARRAY, END_ARRAY); } else { throw new NotImplementedException("element type " + type + " not implemented"); } } } } }
/// <summary> /// Interpolate model elements or environment variables into a string. /// Character sequences like $(NAME) are replaced with the model element NAME. /// Character sequences like ${NAME} are replaced with the environment variable NAME. /// </summary> /// <param name="text">The text in which the replacement happens.</param> /// <param name="handler">The handler from which model elements are read.</param> /// <returns></returns> private static string Interpolate(string text, OplDataHandler handler) { // Return value StringBuilder b = new StringBuilder(text.Length); // The closing parenthesis we are looking for (or NUL) char unquote = '\0'; // The text between open and closing parenthesis. StringBuilder quoted = null; // Was the last character a $ bool dollar = false; foreach (char c in text) { if (unquote != '\0') { if (c == unquote) { switch (unquote) { case ')': // Interpolate model element OplElement elem = handler.getElement(quoted.ToString()); if (elem == null) { throw new SystemException("undefined element " + quoted.ToString() + " referenced in " + text); } if (elem.ElementType.Equals(OplElementType.Type.INT)) { b.Append(elem.AsInt()); } else if (elem.ElementType.Equals(OplElementType.Type.NUM)) { b.Append(elem.AsNum()); } else if (elem.ElementType.Equals(OplElementType.Type.STRING)) { b.Append(elem.AsString()); } else { throw new SystemException("reference element " + quoted.ToString() + " has invalid type " + elem.ElementType); } break; case '}': // Interpolate environment variable. string value = Environment.GetEnvironmentVariable(quoted.ToString()); if (value != null) { b.Append(value); } break; } unquote = '\0'; quoted = null; } else { quoted.Append(c); } } else if (c == '$') { if (dollar) { // $$ is used to mean a literal $ b.Append('$'); dollar = false; } else { dollar = true; } } else if (dollar) { // last character was a $ but current one is not: we must start a quote switch (c) { case '(': unquote = ')'; quoted = new StringBuilder(); break; case '{': unquote = '}'; quoted = new StringBuilder(); break; default: throw new SystemException("ínvalid text " + text); } dollar = false; } else { b.Append(c); } } if (dollar || unquote != '\0') { throw new SystemException("bad quotes in " + text); } return(b.ToString()); }
private void GetResources(OplDataHandler handler) { // initialize the tuple set 'Products' handler.StartElement("Resources"); handler.StartSet(); // Loop through queue foreach (Machine machine in LithographyArea.Machines) { // Check if machine is Down if (LithographyArea.MachineStates[machine.Name] == "Down") { continue; } int initialProductID = -1; int endTimeInitialProductID = 0; // Check if a lot is loaded on the machine if (machine.Queue.Length > 0) { Lot lotAtMachine = machine.Queue.PeekFirst(); initialProductID = ProductNameToID[lotAtMachine.MasksetLayer_RecipeStepCluster]; double estimatedEndTime; if (machine.CurrentLot == lotAtMachine) { estimatedEndTime = machine.CurrentStartRun + machine.GetDeterministicProcessingTime(lotAtMachine); if (estimatedEndTime > LithographyArea.GetTime) { endTimeInitialProductID = (int)estimatedEndTime - (int)LithographyArea.GetTime; } } else { estimatedEndTime = machine.GetDeterministicProcessingTime(lotAtMachine); endTimeInitialProductID = (int)estimatedEndTime; } } if (machine.Name.Contains("#5") || machine.Name.Contains("#7") || machine.Name.Contains("#9")) { // Add tuple handler.StartTuple(); handler.AddStringItem(machine.Name); handler.AddStringItem("MTRX_RMS"); handler.AddIntItem(initialProductID); handler.AddIntItem(endTimeInitialProductID); handler.EndTuple(); } else { // Add tuple handler.StartTuple(); handler.AddStringItem(machine.Name); handler.AddStringItem("MTRX_ARMS"); handler.AddIntItem(initialProductID); handler.AddIntItem(endTimeInitialProductID); handler.EndTuple(); } } handler.EndSet(); handler.EndElement(); }