/// <summary>
        /// Get ready to run by all the cuts that are listed on the command line.
        /// </summary>
        /// <param name="context"></param>
        public override void EnterObjectSpecNameAndCutList(FinalStatePatternParser.ObjectSpecNameAndCutListContext context)
        {
            // Cache the FSO for processing
            _current_fso = Convert(context.object_name());
            _current_criteria.Push(new List<ISelectionCriteriaBase>());

            base.EnterObjectSpecNameAndCutList(context);
        }
 public void EmitAFSOWithNoBaseDefinition()
 {
     var fso = new FinalStateObject() { Name = "hi", BaseDefinition = null };
     var ms = new StringWriter();
     fso.Emit(ms);
     var text = ms.ToString().Trim();
     Assert.AreEqual("atlas:hi rdf:type dfs:PhysicsObject .", text);
 }
 public void EmitFunction()
 {
     var fso1 = new FinalStateObject() { Name = "J1", BaseDefinition = null };
     var fso2 = new FinalStateObject() { Name = "J2", BaseDefinition = null };
     var fpv = new FunctionPhysicalQuantity() { ArgumentList = "J1.pT > 20, ET > 0, J2", Name = "NTrack", RefersToObjects = new FinalStateObject[] { fso1, fso2 } };
     var ms = new StringWriter();
     fpv.Emit(ms);
     var text = ms.ToString().Trim();
     Assert.AreEqual("atlas:functionQuantity0 rdf:type dfs:PhysicalQuantity ;\r\n  dfs:refersToObject atlas:J1 , atlas:J2 ;\r\n  dfs:hasQuantity \"NTrack(J1.pT > 20, ET > 0, J2)\" .", text);
 }
 public void EmitSinglePhysicalValue()
 {
     var fso = new FinalStateObject() { Name = "J1", BaseDefinition = null };
     var spq = new SinglePhysicalQuantity() { RefersToObject = fso, PhysicalQantity = "pT" };
     var ms = new StringWriter();
     spq.Emit(ms);
     var text = ms.ToString().Trim();
     Assert.AreEqual("atlas:physicalQuantity0 rdf:type dfs:PhysicalQuantity ;\r\n  dfs:refersToObject atlas:J1 ;\r\n  dfs:refersToFinalStateObjectProperty dfs:pT .", text);
 }
        /// <summary>
        /// We are doing a stand alone cut on a single line; get things setup to track what happens on exit.
        /// </summary>
        /// <param name="context"></param>
        public override void EnterStandalone_cut(FinalStatePatternParser.Standalone_cutContext context)
        {
            _current_fso = null; // Should already be the case!
            _current_criteria.Push(new List<ISelectionCriteriaBase>());

            // Do the rest.
            base.EnterStandalone_cut(context);
        }
 /// <summary>
 /// When we enter a function argument list processing, make sure to specify what is needed.
 /// </summary>
 /// <param name="context"></param>
 public override void EnterFunction(FinalStatePatternParser.FunctionContext context)
 {
     _current_cut = new FinalStateObject() { Name = string.Format("FuncArg{0}", context.NAME().GetText()) };
     _current_criteria.Push(new List<ISelectionCriteriaBase>());
     base.EnterFunction(context);
 }
        /// <summary>
        /// Given an object name context, extract a FSO.
        /// </summary>
        /// <param name="objNameContext"></param>
        private FinalStateObject Convert(FinalStatePatternParser.Object_nameContext objNameContext, AllowedFSODefinitionReference refType = AllowedFSODefinitionReference.kAsDefinitionOnly)
        {
            var fso_name = objNameContext.NAME().GetText();

            string fso_base_definition = null;
            if (objNameContext.base_definition() != null)
            {
                fso_base_definition = objNameContext.base_definition().GetText();
            }

            var oldFSO = FSOs.Where(f => f.Name == fso_name).FirstOrDefault();
            if (oldFSO != null)
            {
                if (refType == AllowedFSODefinitionReference.kAsDefinitionOnly && oldFSO.BaseDefinition != fso_base_definition)
                {
                    throw new ArgumentOutOfRangeException(string.Format("Object {0} was defined with two base definitions ({1} and {2})", fso_name, fso_base_definition, oldFSO.BaseDefinition));
                }
                return oldFSO;
            }
            else
            {
                var new_fso = new FinalStateObject() { Name = fso_name, BaseDefinition = fso_base_definition };
                FSOs.Add(new_fso);
                return new_fso;
            }
        }
 /// <summary>
 /// When we leave the function, clean up so we don't accidentally re-use the
 /// function context.
 /// </summary>
 /// <param name="context"></param>
 public override void ExitFunction(FinalStatePatternParser.FunctionContext context)
 {
     _current_cut = null;
     _parsed_functions.Enqueue(Convert(context));
     _current_criteria.Pop();
     base.ExitFunction(context);
 }