コード例 #1
0
        public SequenceMultiBacktrackRuleGenerator(SequenceMultiBacktrack seqMulti, SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper)
        {
            this.seqMulti   = seqMulti;
            this.seqRule    = seqRule;
            this.seqExprGen = seqExprGen;
            this.seqHelper  = seqHelper;

            ArgumentExpressions      = seqRule.ArgumentExpressions;
            ReturnVars               = seqRule.ReturnVars;
            specialStr               = seqRule.Special ? "true" : "false";
            matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name;
            patternName              = seqRule.Name;
            plainRuleName            = TypesHelper.PackagePrefixedNameDoubleColon(seqRule.Package, seqRule.Name);
            ruleName    = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name);
            matchType   = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName);
            matchName   = "match_" + seqRule.Id;
            matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">";
            matchesName = "matches_" + seqRule.Id;
        }
コード例 #2
0
        private static void GenerateInternalObjectTypeAttributeInitializer(SequenceCheckingEnvironment env, IGraphModel model, SequenceExpressionNew attributeInitializer, SourceBuilder source)
        {
            if (attributeInitializer.AttributeInitializationList == null)
            {
                return; // plain constructor without attribute initialization list
            }
            string internalObjectType = "GRGEN_MODEL." + attributeInitializer.ConstructedType;

            source.Append("\n");
            source.AppendFront("public static ");
            source.Append(internalObjectType);
            source.Append(" fillFromSequence_" + attributeInitializer.Id + "(");
            BaseObjectType objectType = env.Model.ObjectModel.GetType(attributeInitializer.ConstructedType);

            if (objectType != null)
            {
                source.Append("long uniqueId");
            }
            for (int i = 0; i < attributeInitializer.AttributeInitializationList.Count; ++i)
            {
                KeyValuePair <string, SequenceExpression> attributeInitialization = attributeInitializer.AttributeInitializationList[i];
                if (i > 0 || objectType != null)
                {
                    source.Append(", ");
                }
                string valueType = TypesHelper.XgrsTypeToCSharpType(env.TypeOfMemberOrAttribute(attributeInitializer.ConstructedType, attributeInitialization.Key), model);
                source.AppendFormat("{0} {1}", valueType, "param" + i);
            }
            source.Append(")\n");

            source.AppendFront("{\n");
            source.Indent();
            source.AppendFrontFormat("{0} obj = new {0}({1});\n", internalObjectType, objectType != null ? "uniqueId" : "");
            for (int i = 0; i < attributeInitializer.AttributeInitializationList.Count; ++i)
            {
                KeyValuePair <string, SequenceExpression> attributeInitialization = attributeInitializer.AttributeInitializationList[i];
                source.AppendFrontFormat("obj.{0}  = {1};\n", attributeInitialization.Key, "param" + i);
            }
            source.AppendFront("return obj;\n");
            source.Unindent();
            source.AppendFront("}\n");
        }
コード例 #3
0
ファイル: Helper.cs プロジェクト: jmalarcon/iismailer
        //Appends data line to the CSV file (if there's one)
        internal void AppendToCSVFile()
        {
            bool   csvEnabled = TypesHelper.DoConvert <bool>(GetParamValue("CSV.enabled", "false"));
            string csvPath    = GetParamValue("CSV.path", "");

            if (!csvEnabled || string.IsNullOrEmpty(csvPath))
            {
                return;
            }

            csvPath = GetAbsolutePath(csvPath);

            using (StreamWriter swCSV = new StreamWriter(csvPath, true))    //Open file to append data
            {
                using (CsvFileWriter csvFW = new CsvFileWriter(swCSV))
                {
                    csvFW.WriteRow(GetDataAsList(_data));
                }
            }
        }
コード例 #4
0
        public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, IFunctionDefinition functionMethod, SourceBuilder source)
        {
            String parameters = "";

            for (int i = 0; i < ArgumentExpressions.Length; i++)
            {
                if (ArgumentExpressions[i] != null)
                {
                    String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]);
                    String cast     = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
                    parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source);
                }
                else
                {
                    // the sequence parser always emits all argument expressions, for interpreted and compiled
                    throw new Exception("Internal error: missing argument expressions");
                }
            }
            return(parameters);
        }
コード例 #5
0
        public static void GenerateContainerConstructor(IGraphModel model, SequenceExpressionContainerConstructor containerConstructor, SourceBuilder source)
        {
            string containerType = TypesHelper.XgrsTypeToCSharpType(GetContainerType(containerConstructor), model);
            string valueType     = TypesHelper.XgrsTypeToCSharpType(containerConstructor.ValueType, model);
            string keyType       = null;

            if (containerConstructor is SequenceExpressionMapConstructor)
            {
                keyType = TypesHelper.XgrsTypeToCSharpType(((SequenceExpressionMapConstructor)containerConstructor).KeyType, model);
            }

            source.Append("\n");
            source.AppendFront("public static ");
            source.Append(containerType);
            source.Append(" fillFromSequence_" + containerConstructor.Id);
            source.Append("(");
            for (int i = 0; i < containerConstructor.ContainerItems.Length; ++i)
            {
                if (i > 0)
                {
                    source.Append(", ");
                }
                if (keyType != null)
                {
                    source.AppendFormat("{0} paramkey{1}, ", keyType, i);
                }
                source.AppendFormat("{0} param{1}", valueType, i);
            }
            source.Append(")\n");

            source.AppendFront("{\n");
            source.Indent();
            source.AppendFrontFormat("{0} container = new {0}();\n", containerType);
            for (int i = 0; i < containerConstructor.ContainerItems.Length; ++i)
            {
                source.AppendFrontFormat(GetAddToContainer(containerConstructor, "param" + i, keyType != null ? "paramkey" + i : null));
            }
            source.AppendFront("return container;\n");
            source.Unindent();
            source.AppendFront("}\n");
        }
コード例 #6
0
ファイル: ScriptsEngine.cs プロジェクト: ashamrai/tfevents
        public bool RunScriptWorkItemUpdated(WorkItemEvent.WorkItemEventUpdated pInputWorkItem, TFSServicesDBLib.Rules pRule)
        {
            bool _result = false;

            try
            {
                if (Debug)
                {
                    DBConnection.AddRunHistory(pRule, "Start run: " + pRule.Title, TypesHelper.Serialize(pInputWorkItem));
                }

                var _scrOpt = GetOptions();


                string _srcHeader = @"string ProcessEvent(WorkItemEvent.WorkItemEventUpdated InputWorkItem){";
                string _srcEnd    = @"
}
ProcessEvent(InputWorkItem)";

                string _src = _srcHeader + pRule.ProcessScript + _srcEnd;

                _result = CSharpScript.RunAsync <bool>(_src, _scrOpt, new ScriptWiUpdatedHost {
                    InputWorkItem = pInputWorkItem
                }).Result.ReturnValue;

                if (Debug)
                {
                    DBConnection.AddRunHistory(pRule, "End run: " + pRule.Title, TypesHelper.Serialize(pInputWorkItem));
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    DBConnection.AddRunHistory(pRule, "Validation exception for : " + pRule.Title, ex.Message + "\n\n" + ex.StackTrace);
                }
                _result = false;
            }

            return(_result);
        }
コード例 #7
0
        public Link GetLink(string inLink, Node inNode)
        {
            string linkType      = "";
            string linkPattern   = "Link Type=\"";
            int    linkTypeIndex = inLink.IndexOf(linkPattern);

            if (linkTypeIndex > -1)
            {
                int linkEndIndex = inLink.IndexOf("\"", linkTypeIndex + linkPattern.Length);
                int length       = linkEndIndex - (linkTypeIndex + linkPattern.Length);
                linkType = inLink.Substring(linkTypeIndex + linkPattern.Length, length);
            }
            else
            {
                return(null);
            }

            Link link = (Link)Serializer.LinkSerializers[linkType].Deserialize(TypesHelper.StringToStream(inLink));

            return(link);
        }
コード例 #8
0
        public NodeConnexions(Node inNode, bool inputs, bool outputs, string excludeType)
        {
            _nodeName       = inNode.Name;
            _nodeFullName   = inNode.FullName;
            _nodeNativeName = inNode.NativeName;

            if (inputs)
            {
                foreach (Link inputLink in inNode.InDependencies)
                {
                    if (linkMatches(inputLink, excludeType) && (!(inNode is Compound) || !inputLink.Source.Owner.IsIn(inNode as Compound)))
                    {
                        MemoryStream stream = new MemoryStream();

                        Serializer.LinkSerializers[inputLink.NodeElementType].Serialize(stream, inputLink);
                        string linkSerialization = TypesHelper.StringFromStream(stream);
                        stream.Close();

                        _inputs.PushItemInList(inputLink.Target.Owner.FullName + ":" + inputLink.Target.Name, linkSerialization);
                    }
                }
            }

            if (outputs)
            {
                foreach (Link outputLink in inNode.OutDependencies)
                {
                    if (linkMatches(outputLink, excludeType) && (!(inNode is Compound) || !outputLink.Target.Owner.IsIn(inNode as Compound)))
                    {
                        MemoryStream stream = new MemoryStream();

                        Serializer.LinkSerializers[outputLink.NodeElementType].Serialize(stream, outputLink);
                        string linkSerialization = TypesHelper.StringFromStream(stream);
                        stream.Close();

                        _outputs.PushItemInList(outputLink.Target.Owner.FullName + ":" + outputLink.Target.Name, linkSerialization);
                    }
                }
            }
        }
コード例 #9
0
        public SequenceMultiRuleAllCallGenerator(SequenceMultiRuleAllCall seqMulti, SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper)
        {
            this.seqMulti   = seqMulti; // parent
            this.seqRule    = seqRule;
            this.seqExprGen = seqExprGen;
            this.seqHelper  = seqHelper;

            ArgumentExpressions      = seqRule.ArgumentExpressions;
            specialStr               = seqRule.Special ? "true" : "false";
            matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name;
            patternName              = seqRule.Name;
            plainRuleName            = TypesHelper.PackagePrefixedNameDoubleColon(seqRule.Package, seqRule.Name);
            ruleName    = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name);
            matchType   = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName);
            matchName   = "match_" + seqRule.Id;
            matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">";
            matchesName = "matches_" + seqRule.Id;

            seqHelper.BuildReturnParameters(seqRule, seqRule.ReturnVars,
                                            out returnParameterDeclarations, out returnArguments, out returnAssignments,
                                            out returnParameterDeclarationsAllCall, out intermediateReturnAssignmentsAllCall, out returnAssignmentsAllCall);
        }
コード例 #10
0
        /// <summary>
        /// Locate all value matcher classes and add them to the value matchers list using reflection (or just manually as below)
        /// </summary>
        private static Dictionary <string, TAGValueMatcher> InitialiseValueMatchers()
        {
            // Get all the value matcher classes that exist in the assembly. These are all classes that
            // descend from TAGValueMatcher
            var matchers = TypesHelper.FindAllDerivedTypes <TAGValueMatcher>();

            var valueMatchers = new Dictionary <string, TAGValueMatcher>();

            // Iterate through those types and create each on in turn, query the TAG types from it that the matcher supports and
            // then register the value matcher instance against those TAGs to allow the TAG file processor to locate matcher for TAGS
            foreach (var t in matchers)
            {
                var matcher = (TAGValueMatcher)Activator.CreateInstance(t);

                foreach (string tag in matcher.MatchedValueTypes())
                {
                    valueMatchers.Add(tag, matcher);
                }
            }

            return(valueMatchers);
        }
コード例 #11
0
        public void LoadData(int method = 0)
        {
            NameValueCollection nvc = null;

            switch (method)
            {
            case 0: nvc = HttpContext.Current.Request.Params; break;

            case 1: nvc = HttpContext.Current.Request.Form; break;

            case 2: nvc = HttpContext.Current.Request.QueryString; break;
            }

            if (nvc.Count != 0)
            {
                var ti = TypesHelper.GetTypeInfo(this.GetType()); //缓存中获取
                var li = ti.IgnoreCaseLiteracy;

                foreach (var key in nvc.AllKeys)
                {
                    var item = key.ToLower();
                    if (li.Property.Names.Contains(item))
                    {
                        string value = nvc[item];
                        if (!string.IsNullOrEmpty(value))
                        {
                            li.Property[item].SetValue(this, value);
                        }
                        else
                        {
                            if (li.Property[item].GetType() == typeof(string))
                            {
                                li.Property[item].SetValue(this, "");
                            }
                        }
                    }
                }
            }
        }
コード例 #12
0
        ///
        /// <summary>Main for TypesClient</summary>
        /// <param name="args"></param>
        ///
        public static void Main(String[] args)
        {
            string uri = "tcp://localhost:4001";

            MainTypesListener.Main1(null);
            MainTypesClient   implFactory = new MainTypesClient();
            RemoteTypesServer server      = TypesHelper.NewServer(uri, null, implFactory);

            server._TransportControl(TransportConsts.START_AND_WAIT_UP, 4000);

            Hashtable table = new Hashtable();

            table.Add("1", "Entry1");
            table.Add("2", "Entry2");

            IDictionary map1 = server.test1(table);


            ArrayList list = new ArrayList();

            list.Add("List1");
            IList list1 = server.test3(list);



            DateTime?date = server.test4(DateTime.Now);


            Hashtable set = new Hashtable();

            set.Add("1", null);
            set.Add("2", null);


            Hashtable retset = server.test2(set);

            server._TransportControl(TransportConsts.STOP_AND_WAIT_DOWN, 4000);
        }
コード例 #13
0
        public String BuildParametersInDeclarations(Invocation invocation, SequenceExpression[] ArgumentExpressions, SourceBuilder source, out String declarations)
        {
            String parameters = "";

            declarations = "";
            for (int i = 0; i < ArgumentExpressions.Length; i++)
            {
                String typeName;
                if (actionsTypeInformation.rulesToInputTypes.ContainsKey(invocation.PackagePrefixedName))
                {
                    typeName = actionsTypeInformation.rulesToInputTypes[invocation.PackagePrefixedName][i];
                }
                else
                {
                    typeName = actionsTypeInformation.sequencesToInputTypes[invocation.PackagePrefixedName][i];
                }
                String type = TypesHelper.XgrsTypeToCSharpType(typeName, model);
                String name = "tmpvar_" + GetUniqueId();
                declarations += type + " " + name + " = " + "(" + type + ")" + exprGen.GetSequenceExpression(ArgumentExpressions[i], source) + ";";
                parameters   += ", " + name;
            }
            return(parameters);
        }
コード例 #14
0
        public static IEnumerable <EVEMaterial> GetInventionRequirements(string t2ItemName)
        {
            List <EVEMaterial> result = new List <EVEMaterial>();

            invType          t1type = TypesHelper.GetMeta0Type(t2ItemName);
            invBlueprintType bpType = TypesHelper.GetBlueprintType(t1type);
            IEnumerable <ramTypeRequirement> ramReqs = TypesHelper.GetRamTypeRequirements(bpType).Where(x => x.activityID == 8);

            foreach (ramTypeRequirement r in ramReqs)
            {
                invType     reqType = TypesHelper.GetType(r.requiredTypeID);
                EVEMaterial newMat  = new EVEMaterial(EVECache.GetItem(reqType), r.quantity.Value, r.damagePerJob.Value, true);

                if (reqType.groupID == 716)
                {
                    newMat.damage = 0;
                }

                result.Add(newMat);
            }

            return(result);
        }
コード例 #15
0
        public static EVEBlueprint GetBlueprint(string productTypeName)
        {
            EVEBlueprint blueprint = new EVEBlueprint();

            if (productTypeName != null)
            {
                blueprint.Product = EVECache.GetItem(productTypeName);
            }

            var x = TypesHelper.GetBlueprintType(blueprint.Product.TypeID);

            blueprint.Blueprint = EVECache.GetItem(x.blueprintTypeID);

            blueprint.MaxRuns            = x.maxProductionLimit.Value;
            blueprint.BaseInventionTime  = x.researchTechTime.Value;
            blueprint.BaseProductionTime = x.productionTime.Value;

            blueprint.MaterialEfficiency   = -4;
            blueprint.ProductionEfficiency = -4;
            blueprint.NumRuns = blueprint.MaxRuns / 10;

            return(blueprint);
        }
コード例 #16
0
        /// <summary>
        /// Returns the types to which the operands must be casted to,
        /// assuming an external type equality or ordering operator.
        /// Returns "" if the type can only be determined at runtime.
        /// Returns "-" in case of a type error and/or if no operator working on external types can be applied.
        /// </summary>
        private static string BalanceExternalType(string left, string right, IGraphModel model)
        {
            if (left == right)
            {
                return(left);
            }

            if (left == "" || right == "")
            {
                return("");
            }

            if (TypesHelper.IsSameOrSubtype(left, right, model) && TypesHelper.IsExternalTypeIncludingObjectType(right, model))
            {
                return(right);
            }

            if (TypesHelper.IsSameOrSubtype(right, left, model) && TypesHelper.IsExternalTypeIncludingObjectType(left, model))
            {
                return(left);
            }

            return("-");
        }
コード例 #17
0
ファイル: WrapRequest.cs プロジェクト: isilveira/ModelWrapper
        /// <summary>
        /// Method that sets a property value into model object
        /// </summary>
        /// <param name="propertyName">Property name</param>
        /// <param name="propertyValue">Property value</param>
        internal void SetPropertyValue(
            string propertyName,
            object propertyValue
            )
        {
            var property = Model.GetType().GetProperties().SingleOrDefault(p => p.Name.ToLower().Equals(propertyName.ToLower()));

            if (property != null)
            {
                Type propertyType = property.PropertyType;
                if (Nullable.GetUnderlyingType(propertyType) != null)
                {
                    propertyType = Nullable.GetUnderlyingType(propertyType);
                }

                SetConfigProperty(Constants.CONST_SUPPLIED, property.Name);
                if (propertyValue is JToken)
                {
                    var newPropertyValue = JsonConvert.DeserializeObject(propertyValue.ToString(), property.PropertyType);
                    property.SetValue(this.Model, newPropertyValue);
                }
                else if (propertyValue != null)
                {
                    bool changed          = false;
                    var  newPropertyValue = TypesHelper.TryChangeType(propertyValue.ToString(), property.PropertyType, out changed);
                    if (changed)
                    {
                        property.SetValue(this.Model, newPropertyValue);
                    }
                }
                else
                {
                    property.SetValue(this.Model, propertyValue);
                }
            }
        }
コード例 #18
0
        /// <summary>
        /// Method that extends IWrapRequest<T> allowing to get filter properties from request
        /// </summary>
        /// <typeparam name="TModel">Generic type of the entity</typeparam>
        /// <param name="source">Self IWrapRequest<T> instance</param>
        /// <returns>Returns a dictionary with properties and values found</returns>
        internal static List <FilterProperty> FilterProperties <TModel>(
            this IWrapRequest <TModel> source
            ) where TModel : class
        {
            var filterProperties = new List <FilterProperty>();

            foreach (var property in typeof(TModel).GetProperties().Where(x =>
                                                                          !source.IsPropertySuppressed(x.Name)
                                                                          ).ToList())
            {
                foreach (var criteria in CriteriasHelper.GetPropertyTypeCriteria(property.PropertyType))
                {
                    var criteriaName = $"{property.Name.ToCamelCase()}{criteria}";
                    var listObjects  = new List <object>();
                    foreach (var value in source.AllProperties.Where(x =>
                                                                     x.Name.ToLower().Equals(criteriaName.ToLower())
                                                                     ).Select(x => x.Value).ToList())
                    {
                        bool   changed    = false;
                        object typedValue = TypesHelper.TryChangeType(value.ToString(), property.PropertyType, out changed);
                        if (changed)
                        {
                            listObjects.Add(typedValue);
                        }
                    }
                    if (listObjects.Count > 0)
                    {
                        filterProperties.Add(new FilterProperty {
                            Name = criteriaName, Value = listObjects.Count > 1 ? listObjects : listObjects.FirstOrDefault()
                        });
                    }
                }
            }

            return(filterProperties);
        }
コード例 #19
0
        public ContainerContext(IContainerConfiguration configuration, IClassWrapperCreator classWrapperCreator)
        {
            this.Configuration  = configuration;
            ClassWrapperCreator = classWrapperCreator;
            typesHelper         = new TypesHelper();

            var funcHelper = new FuncHelper();

            FuncBuilder = new FuncBuilder();
            var classCreator        = new ClassCreator(funcHelper);
            var constructorSelector = new ConstructorSelector();

            CreationContext = new CreationContext(classCreator, constructorSelector, classWrapperCreator);

            var implementationTypesCollection = new ImplementationTypesCollection(configuration, typesHelper);

            ImplementationCache              = new ImplementationCache();
            abstractionsCollection           = new AbstractionsCollection(implementationTypesCollection, ImplementationCache); //g
            ImplementationConfigurationCache = new ImplementationConfigurationCache();                                         //l
            var factory = new AutoAbstractionConfigurationFactory(typesHelper, abstractionsCollection, ImplementationConfigurationCache);

            AbstractionConfigurationCollection = new AbstractionConfigurationCollection(factory);
            AbstractionConfigurationCollection.Add(typeof(IContainer), new StupidAbstractionConfiguration(new ContainerImplementationConfiguration()));
        }
コード例 #20
0
        private void LblFiltrar_Click(object sender, EventArgs e)
        {
            try
            {
                #region Validaciones

                var filtersSetted    = false;
                var exceptionMessage = string.Empty;

                if (!TypesHelper.IsEmpty(CboAño.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(CboTrimestre.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(CboListado.Text))
                {
                    filtersSetted = true;
                }

                if ((int)CboListado.SelectedValue == 1 && !TypesHelper.IsEmpty(CboVisibilidad.Text))
                {
                    filtersSetted = true;
                }

                if (!filtersSetted)
                {
                    exceptionMessage = "No se puede obtener el listado estadístico. Verifique que haya ingresado los filtros correctamente.";
                }

                if (!TypesHelper.IsEmpty(exceptionMessage))
                {
                    throw new Exception(exceptionMessage);
                }

                #endregion

                var monthDesde = "";
                var dayHasta   = "";
                var monthHasta = "";

                //Si es la primera estadística, puede que esté filtrada por mes, si está en 00, filtro por trimestre
                if ((string)cboMes.SelectedValue == "00" || (int)CboListado.SelectedValue != 1)
                {
                    switch ((int)CboTrimestre.SelectedValue)
                    {
                    case 1: monthDesde = "01"; monthHasta = "03"; break;

                    case 2: monthDesde = "04"; monthHasta = "06"; break;

                    case 3: monthDesde = "07"; monthHasta = "09"; break;

                    case 4: monthDesde = "10"; monthHasta = "12"; break;
                    }
                }
                else
                {
                    monthDesde = monthHasta = (string)cboMes.SelectedValue;
                }

                switch (monthHasta)
                {
                case "01":
                case "03":
                case "05":
                case "07":
                case "08":
                case "10":
                case "12": dayHasta = "31"; break;

                case "04":
                case "06":
                case "09":
                case "11": dayHasta = "30"; break;

                case "02": dayHasta = "28"; break;
                }

                var fechaDesde = DateTime.Parse("01/" + monthDesde + "/" + CboAño.SelectedValue.ToString());
                var fechaHasta = DateTime.Parse(dayHasta + "/" + monthHasta + "/" + CboAño.SelectedValue.ToString());

                //Creo los filtros con los que se ejecuta la consulta.
                var filters = new EstadisticaFilters
                {
                    FechaDesde  = fechaDesde,
                    FechaHasta  = fechaHasta,
                    Visibilidad = (!TypesHelper.IsEmpty(CboVisibilidad.Text) && (int)CboVisibilidad.SelectedValue != 0) ? (int)CboVisibilidad.SelectedValue : (int?)null
                };

                var listado = new List <Estadistica>();
                switch ((int)CboListado.SelectedValue)
                {
                case 1:
                    listado = EstadisticaPersistance.GetSellersWithMoreProductsNotSold(filters);
                    break;

                case 2:
                    listado = EstadisticaPersistance.GetSellersWithMoreBilling(filters);
                    break;

                case 3:
                    listado = EstadisticaPersistance.GetSellersWithBetterQualifications(filters);
                    break;

                case 4:
                    listado = EstadisticaPersistance.GetClientsWithMoreNotQualifiedPublications(filters);
                    break;
                }

                if (listado == null || listado.Count == 0)
                {
                    throw new Exception("No se encontraron estadísticas según los filtros informados.");
                }

                LoadGrid(listado);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Atención");
                ClearDataGridView();
            }
        }
コード例 #21
0
ファイル: DictionaryForm.cs プロジェクト: Lootero4eg/anvlib
        private void CreateControls()
        {
            #region Fields Creation
            foreach (var item in _editableItem.GetType().GetProperties())
            {
                bool standard = false;
                bool generic  = false;
                bool array    = false;

                //--Standard type
                if (TypesHelper.IsStandardType(item.PropertyType))
                {
                    if (item.PropertyType != typeof(bool))
                    {
                        Label lb = new Label();
                        lb.Text     = item.Name + ":";
                        lb.Top      = (this.Controls.Count * lb.Height);
                        lb.Left     = 2;
                        lb.AutoSize = true;
                        lb.SendToBack();
                        this.Controls.Add(lb);
                        TextBox tb = new TextBox();
                        tb.Top  = (this.Controls.Count * tb.Height);
                        tb.Left = 2;
                        tb.Name = string.Format("{0}_{1}", item.Name, "TextBox");
                        this.Controls.Add(tb);
                        _controlsBindings.Add(tb.Name, item.Name);
                    }
                    standard = true;
                }

                #region Generic type
                if (item.PropertyType.IsGenericType)
                {
                    generic = true;
                }
                #endregion

                #region Array Type
                if (item.PropertyType.IsArray)
                {
                    Type eltype = item.PropertyType.GetElementType();
                    if (TypesHelper.IsStandardType(eltype))
                    {
                    }

                    if (eltype.IsGenericType)
                    {
                    }

                    array = true;
                }
                #endregion

                #region Class type
                if (!standard && !generic && !array)
                {
                }
                #endregion
            }
            #endregion

            #region Ok & Cancel Buttons Creation
            Button but = new Button();
            but.Text = "ОК";
            but.Top  = (this.Controls.Count * but.Height);
            but.Left = 2;
            this.Controls.Add(but);
            but      = new Button();
            but.Text = "Отмена";
            but.Top  = this.Controls[this.Controls.Count - 1].Top;
            but.Left = this.Controls[this.Controls.Count - 1].Width + 6;
            this.Controls.Add(but);
            #endregion
        }
コード例 #22
0
 public override void SetUp()
 {
     base.SetUp();
     helpers = new TypesHelper();
 }
コード例 #23
0
        public void Run(Options options)
        {
            GlobalScope globalScope = new GlobalScope();

            Loader ld = new Loader(globalScope, options);

            ld.Load(options.References);

            Types.RegisterType("Boolean", (IType)globalScope.GetSymbol("System.Boolean"));
            Types.RegisterType("Char", (IType)globalScope.GetSymbol("System.Char"));
            Types.RegisterType("SByte", (IType)globalScope.GetSymbol("System.SByte"));
            Types.RegisterType("Byte", (IType)globalScope.GetSymbol("System.Byte"));
            Types.RegisterType("Int16", (IType)globalScope.GetSymbol("System.Int16"));
            Types.RegisterType("UInt16", (IType)globalScope.GetSymbol("System.UInt16"));
            Types.RegisterType("Int32", (IType)globalScope.GetSymbol("System.Int32"));
            Types.RegisterType("UInt32", (IType)globalScope.GetSymbol("System.UInt32"));
            Types.RegisterType("Int64", (IType)globalScope.GetSymbol("System.Int64"));
            Types.RegisterType("UInt64", (IType)globalScope.GetSymbol("System.UInt64"));
            Types.RegisterType("IntPtr", (IType)globalScope.GetSymbol("System.IntPtr"));
            Types.RegisterType("UIntPtr", (IType)globalScope.GetSymbol("System.UIntPtr"));
            Types.RegisterType("Single", (IType)globalScope.GetSymbol("System.Single"));
            Types.RegisterType("Double", (IType)globalScope.GetSymbol("System.Double"));
            Types.RegisterType("String", (IType)globalScope.GetSymbol("System.String"));
            Types.RegisterType("Object", (IType)globalScope.GetSymbol("System.Object"));
            Types.RegisterType("ValueType", (IType)globalScope.GetSymbol("System.ValueType"));
            Types.RegisterType("Enum", (IType)globalScope.GetSymbol("System.Enum"));
            Types.RegisterType("Void", (IType)globalScope.GetSymbol("System.Void"));
            Types.RegisterType("Array", (IType)globalScope.GetSymbol("System.Array"));
            Types.RegisterType("Exception", (IType)globalScope.GetSymbol("System.Exception"));
            Types.RegisterType("Type", (IType)globalScope.GetSymbol("System.Type"));
            Types.RegisterType("MulticastDelegate", (IType)globalScope.GetSymbol("System.MulticastDelegate"));
            Types.RegisterType("IAsyncResult", (IType)globalScope.GetSymbol("System.IAsyncResult"));
            Types.RegisterType("AsyncCallback", (IType)globalScope.GetSymbol("System.AsyncCallback"));

            TypesHelper th = new TypesHelper();

            th.Prepare();
            Types.ResultTable    = th.ResultTable;
            Types.PromotionTable = th.PromotionTable;

            int files_number = options.FilesNumber;

            if (files_number == 0)
            {
                Report.Error.NoFilesToCompile();
            }

            List <FileNamespace>   file_namespace    = new List <FileNamespace>();
            List <CompilationUnit> compilation_units = new List <CompilationUnit>();

            foreach (string source in options.Files)
            {
                try
                {
                    FileStream file = new FileStream(source, FileMode.Open, FileAccess.Read);

                    ANTLRInputStream input = new ANTLRInputStream(file);

                    GrammarLexer lexer = new GrammarLexer(input);

                    CommonTokenStream tokens = new CommonTokenStream(lexer);

                    GrammarParser parser = new GrammarParser(tokens);

                    compilation_units.Add(parser.program());
                    file_namespace.Add(new FileNamespace(globalScope));
                }
                catch (FileNotFoundException)
                {
                    Report.Error.SourceFileNotFound(source);
                }
                catch (DirectoryNotFoundException)
                {
                    Report.Error.SourceFileNotFound(source);
                }
                catch (IOException)
                {
                    Report.Error.IOError(source);
                }
            }

            CodeGen codegen = new CodeGen(options);

            for (int i = 0; i < files_number; ++i)
            {
                compilation_units[i].DefineSymbols(new Context(file_namespace[i]));
            }

            for (int i = 0; i < files_number; ++i)
            {
                compilation_units[i].ResolveSymbols(new Context(file_namespace[i]));
            }

            codegen.BuildAssembly(compilation_units);
        }
コード例 #24
0
        private static List <SelectedProperty> GetValidProperties <TModel>(
            IWrapRequest <TModel> source,
            Type type,
            List <string> requestProperties,
            string rootName       = null,
            bool isFromCollection = false)
            where TModel : class
        {
            var properties = new List <SelectedProperty>();

            type.GetProperties()
            .Where(property =>
                   !source.IsPropertySuppressedResponse(string.Join(".", TermsHelper.GetTerms(rootName, ".").Union(new List <string> {
                property.Name
            }).Where(term => !string.IsNullOrWhiteSpace(term)))) &&
                   (
                       (requestProperties.Count == 0 && IsToLoadComplexPropertyWhenNotRequested(TypesHelper.TypeIsComplex(property.PropertyType), ConfigurationService.GetConfiguration().ByDefaultLoadComplexProperties, string.IsNullOrWhiteSpace(rootName))) ||
                       (requestProperties.Any(requested => TermsHelper.GetTerms(requested, ".").FirstOrDefault().ToLower().Equals(property.Name.ToLower())))
                   )
                   )
            .ToList()
            .ForEach(property =>
            {
                if (!TypesHelper.TypeIsComplex(property.PropertyType))
                {
                    properties.Add(new SelectedProperty
                    {
                        RequestedPropertyName = string.Join(".", TermsHelper.GetTerms(rootName, ".").Union(new List <string> {
                            property.Name
                        }).Where(term => !string.IsNullOrWhiteSpace(term))),
                        PropertyName     = property.Name,
                        RootPropertyName = rootName,
                        PropertyType     = property.PropertyType,
                        PropertyInfo     = property
                    });
                }
                else if (ConfigurationService.GetConfiguration().ByDefaultLoadComplexProperties)
                {
                    properties.AddRange(
                        GetValidProperties(
                            source,
                            TypesHelper.TypeIsCollection(property.PropertyType) ? property.PropertyType.GetGenericArguments()[0] : property.PropertyType,
                            requestProperties
                            .Where(requested => TermsHelper.GetTerms(requested, ".").FirstOrDefault().ToLower().Equals(property.Name.ToLower()))
                            .Select(requested => string.Join(".", TermsHelper.GetTerms(requested, ".").Skip(1)))
                            .Where(requested => !string.IsNullOrWhiteSpace(requested))
                            .ToList(),
                            string.Join(".", TermsHelper.GetTerms(rootName, ".").Union(new List <string> {
                        property.Name
                    }).Where(term => !string.IsNullOrWhiteSpace(term))),
                            TypesHelper.TypeIsCollection(property.PropertyType)
                            )
                        );
                }
            });

            return(properties);
        }
コード例 #25
0
        public string GetEndpointKey(Type type)
        {
            string mask = EndpointMask ?? MaskVariable;

            return(mask.Replace(MaskVariable, TypesHelper.GetFlatClassName(type)));
        }
コード例 #26
0
        private void GenerateInternalDefinedSequenceApplicationMethod(SourceBuilder source, DefinedSequenceInfo sequence, Sequence seq)
        {
            source.AppendFront("public static bool ApplyXGRS_" + sequence.Name + "(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv");
            for (int i = 0; i < sequence.Parameters.Length; ++i)
            {
                source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]), model) + " var_");
                source.Append(sequence.Parameters[i]);
            }
            for (int i = 0; i < sequence.OutParameters.Length; ++i)
            {
                source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model) + " var_");
                source.Append(sequence.OutParameters[i]);
            }
            source.Append(")\n");
            source.AppendFront("{\n");
            source.Indent();

            source.AppendFront("GRGEN_LGSP.LGSPGraph graph = procEnv.graph;\n");
            source.AppendFront("GRGEN_LGSP.LGSPActions actions = procEnv.curActions;\n");

            neededEntitiesEmitter.Reset();

            if (fireDebugEvents)
            {
                source.AppendFrontFormat("procEnv.DebugEntering(\"{0}\"", sequence.Name);
                for (int i = 0; i < sequence.Parameters.Length; ++i)
                {
                    source.Append(", var_");
                    source.Append(sequence.Parameters[i]);
                }
                source.Append(");\n");
            }

            neededEntitiesEmitter.EmitNeededVarAndRuleEntities(seq, source);

            seqGen.EmitSequence(seq, source);

            if (fireDebugEvents)
            {
                source.AppendFrontFormat("procEnv.DebugExiting(\"{0}\"", sequence.Name);
                for (int i = 0; i < sequence.OutParameters.Length; ++i)
                {
                    source.Append(", var_");
                    source.Append(sequence.OutParameters[i]);
                }
                source.Append(");\n");
            }

            source.AppendFront("return " + seqGen.GetSequenceResult(seq) + ";\n");
            source.Unindent();
            source.AppendFront("}\n");

            List <SequenceExpressionContainerConstructor> containerConstructors = new List <SequenceExpressionContainerConstructor>();
            Dictionary <SequenceVariable, SetValueType>   variables             = new Dictionary <SequenceVariable, SetValueType>();

            seq.GetLocalVariables(variables, containerConstructors, null);
            foreach (SequenceExpressionContainerConstructor cc in containerConstructors)
            {
                SequenceContainerConstructorEmitter.GenerateContainerConstructor(model, cc, source);
            }
        }
コード例 #27
0
        public bool GenerateXGRSCode(string xgrsName, String package, String xgrsStr,
                                     String[] paramNames, GrGenType[] paramTypes,
                                     String[] defToBeYieldedToNames, GrGenType[] defToBeYieldedToTypes,
                                     SourceBuilder source, int lineNr)
        {
            Dictionary <String, String> varDecls = new Dictionary <String, String>();

            for (int i = 0; i < paramNames.Length; ++i)
            {
                varDecls.Add(paramNames[i], TypesHelper.DotNetTypeToXgrsType(paramTypes[i]));
            }
            for (int i = 0; i < defToBeYieldedToNames.Length; ++i)
            {
                varDecls.Add(defToBeYieldedToNames[i], TypesHelper.DotNetTypeToXgrsType(defToBeYieldedToTypes[i]));
            }

            Sequence seq;

            try
            {
                SequenceParserEnvironmentCompiled parserEnv = new SequenceParserEnvironmentCompiled(package, actionNames, model);
                List <string> warnings = new List <string>();
                seq = SequenceParser.ParseSequence(xgrsStr, parserEnv, varDecls, warnings);
                foreach (string warning in warnings)
                {
                    Console.Error.WriteLine("The exec statement \"" + xgrsStr
                                            + "\" given on line " + lineNr + " reported back:\n" + warning);
                }
                seq.Check(env);
                seq.SetNeedForProfilingRecursive(emitProfiling);
            }
            catch (ParseException ex)
            {
                Console.Error.WriteLine("The exec statement \"" + xgrsStr
                                        + "\" given on line " + lineNr + " caused the following error:\n" + ex.Message);
                return(false);
            }
            catch (SequenceParserException ex)
            {
                Console.Error.WriteLine("The exec statement \"" + xgrsStr
                                        + "\" given on line " + lineNr + " caused the following error:\n");
                HandleSequenceParserException(ex);
                return(false);
            }

            source.Append("\n");
            source.AppendFront("public static bool ApplyXGRS_" + xgrsName + "(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv");
            for (int i = 0; i < paramNames.Length; ++i)
            {
                source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(paramTypes[i]), model) + " var_");
                source.Append(paramNames[i]);
            }
            for (int i = 0; i < defToBeYieldedToTypes.Length; ++i)
            {
                source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(defToBeYieldedToTypes[i]), model) + " var_");
                source.Append(defToBeYieldedToNames[i]);
            }
            source.Append(")\n");
            source.AppendFront("{\n");
            source.Indent();

            source.AppendFront("GRGEN_LGSP.LGSPGraph graph = procEnv.graph;\n");
            source.AppendFront("GRGEN_LGSP.LGSPActions actions = procEnv.curActions;\n");

            neededEntitiesEmitter.Reset();

            if (fireDebugEvents)
            {
                source.AppendFrontFormat("procEnv.DebugEntering(\"{0}\", \"{1}\");\n",
                                         InjectExec(xgrsName), xgrsStr.Replace("\\", "\\\\").Replace("\"", "\\\""));
            }

            neededEntitiesEmitter.EmitNeededVarAndRuleEntities(seq, source);

            seqGen.EmitSequence(seq, source);

            if (fireDebugEvents)
            {
                source.AppendFrontFormat("procEnv.DebugExiting(\"{0}\");\n",
                                         InjectExec(xgrsName));
            }

            source.AppendFront("return " + seqGen.GetSequenceResult(seq) + ";\n");
            source.Unindent();
            source.AppendFront("}\n");

            List <SequenceExpressionContainerConstructor> containerConstructors = new List <SequenceExpressionContainerConstructor>();
            Dictionary <SequenceVariable, SetValueType>   variables             = new Dictionary <SequenceVariable, SetValueType>();

            seq.GetLocalVariables(variables, containerConstructors, null);
            foreach (SequenceExpressionContainerConstructor cc in containerConstructors)
            {
                SequenceContainerConstructorEmitter.GenerateContainerConstructor(model, cc, source);
            }

            return(true);
        }
コード例 #28
0
        private void LblBuscar_Click(object sender, EventArgs e)
        {
            try
            {
                #region Validations

                var filtersSetted    = false;
                var exceptionMessage = string.Empty;

                if (!TypesHelper.IsEmpty(txtCodigo.Text))
                {
                    filtersSetted = true;
                    if (!TypesHelper.IsNumeric(txtCodigo.Text))
                    {
                        exceptionMessage += Environment.NewLine + "El código debe ser numérico.";
                    }
                }
                if (!TypesHelper.IsEmpty(txtDesc.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(txtPrecio.Text))
                {
                    filtersSetted = true;
                    if (!TypesHelper.IsDecimal(txtPrecio.Text))
                    {
                        exceptionMessage += Environment.NewLine + "El precio de la publicacion ser decimal (o numérico).";
                    }
                }

                if (!TypesHelper.IsEmpty(txtFecha.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(txtCantidad.Text))
                {
                    filtersSetted = true;
                    if (!TypesHelper.IsNumeric(txtCantidad.Text))
                    {
                        exceptionMessage += Environment.NewLine + "La cantidad debe ser numérica.";
                    }
                }


                if (!filtersSetted)
                {
                    exceptionMessage = "No se puede realizar la busqueda ya que no se informó ningún filtro";
                }

                if (!TypesHelper.IsEmpty(exceptionMessage))
                {
                    throw new Exception(exceptionMessage);
                }

                #endregion

                var filters = new HistoryCompraFilters
                {
                    Codigo      = (!TypesHelper.IsEmpty(txtCodigo.Text)) ? Convert.ToInt32(txtCodigo.Text) : (int?)null,
                    Descripcion = (!TypesHelper.IsEmpty(txtDesc.Text)) ? txtDesc.Text : null,
                    Precio      = (!TypesHelper.IsEmpty(txtPrecio.Text)) ? Convert.ToDouble(txtPrecio.Text) : (double?)null,
                    Fecha       = (!TypesHelper.IsEmpty(txtFecha.Text)) ? txtFecha.Text : null,
                    Cantidad    = (!TypesHelper.IsEmpty(txtCantidad.Text)) ? Convert.ToInt32(txtCantidad.Text) : (int?)null
                };

                var historyCompras = (cBExact.Checked) ? CompraPersistance.GetAllComprasByParameters(SessionManager.CurrentUser, filters) : CompraPersistance.GetAllComprasByParametersLike(SessionManager.CurrentUser, filters);

                if (historyCompras == null || historyCompras.Count == 0)
                {
                    throw new Exception("No se encontraron compras según los filtros informados.");
                }

                RefreshSources(historyCompras);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Atención");
                ClearFiltersAndTable();
            }
        }
コード例 #29
0
        private void LblBuscar_Click(object sender, EventArgs e)
        {
            try
            {
                #region Validations

                var filtersSetted    = false;
                var exceptionMessage = string.Empty;

                if (!TypesHelper.IsEmpty(TxtDescripcion.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(TxtStock.Text))
                {
                    filtersSetted = true;
                    if (!TypesHelper.IsNumeric(TxtStock.Text))
                    {
                        exceptionMessage += Environment.NewLine + "El stock de la publicacion debe ser numérico.";
                    }
                }

                if (!TypesHelper.IsEmpty(TxtPrecio.Text))
                {
                    filtersSetted = true;
                    if (!TypesHelper.IsDecimal(TxtPrecio.Text))
                    {
                        exceptionMessage += Environment.NewLine + "El precio de la publicacion debe ser decimal (o numérico).";
                    }
                }

                if (!TypesHelper.IsEmpty(CboEstadoPublicacion.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(CboVisibilidad.Text))
                {
                    filtersSetted = true;
                }

                if (!TypesHelper.IsEmpty(CboTipoPublicacion.Text))
                {
                    filtersSetted = true;
                }

                if (!filtersSetted)
                {
                    exceptionMessage = "No se puede realizar la busqueda ya que no se informó ningún filtro";
                }

                if (!TypesHelper.IsEmpty(exceptionMessage))
                {
                    throw new Exception(exceptionMessage);
                }

                #endregion

                //Armo el objeto que representa a los filtros
                var filters = new PublicacionFilters
                {
                    IdUsuario           = SessionManager.CurrentUser.ID,
                    Descripcion         = (!TypesHelper.IsEmpty(TxtDescripcion.Text)) ? TxtDescripcion.Text : null,
                    Stock               = (!TypesHelper.IsEmpty(TxtStock.Text) && ChkBusquedaExacta.Checked) ? Convert.ToInt32(TxtStock.Text) : (int?)null,
                    Precio              = (!TypesHelper.IsEmpty(TxtPrecio.Text) && ChkBusquedaExacta.Checked) ? Convert.ToDouble(TxtPrecio.Text) : (double?)null,
                    IdEstadoPublicacion = (ChkBusquedaExacta.Checked) ? ((EstadoPublicacion)CboEstadoPublicacion.SelectedItem).ID : (int?)null,
                    IdVisibilidad       = (ChkBusquedaExacta.Checked) ? ((Visibilidad)CboVisibilidad.SelectedItem).ID : (int?)null,
                    IdTipoPublicacion   = (ChkBusquedaExacta.Checked) ? ((TipoPublicacion)CboTipoPublicacion.SelectedItem).ID : (int?)null
                };

                //Obtengo las publicaciones que cumplen con la busqueda
                var publications = (ChkBusquedaExacta.Checked) ? PublicacionPersistance.GetAllByParameters(filters) : PublicacionPersistance.GetAllByParametersLike(filters);

                if (publications == null || publications.Count == 0)
                {
                    throw new Exception("No se encontraron publicaciones según los filtros informados.");
                }

                //Cargo el resultado en la grilla
                RefreshSources(publications);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Atención");
            }
        }
コード例 #30
0
        public bool GenerateDefinedSequence(SourceBuilder source, DefinedSequenceInfo sequence)
        {
            Dictionary <String, String> varDecls = new Dictionary <String, String>();

            for (int i = 0; i < sequence.Parameters.Length; i++)
            {
                varDecls.Add(sequence.Parameters[i], TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]));
            }
            for (int i = 0; i < sequence.OutParameters.Length; i++)
            {
                varDecls.Add(sequence.OutParameters[i], TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]));
            }

            Sequence seq;

            try
            {
                SequenceParserEnvironmentCompiled parserEnv = new SequenceParserEnvironmentCompiled(sequence.Package, actionNames, model);
                List <string> warnings = new List <string>();
                seq = SequenceParser.ParseSequence(sequence.XGRS, parserEnv, varDecls, warnings);
                foreach (string warning in warnings)
                {
                    Console.Error.WriteLine("In the defined sequence " + sequence.Name
                                            + " the exec part \"" + sequence.XGRS
                                            + "\" reported back:\n" + warning);
                }
                seq.Check(env);
                seq.SetNeedForProfilingRecursive(emitProfiling);
            }
            catch (ParseException ex)
            {
                Console.Error.WriteLine("In the defined sequence " + sequence.Name
                                        + " the exec part \"" + sequence.XGRS
                                        + "\" caused the following error:\n" + ex.Message);
                return(false);
            }
            catch (SequenceParserException ex)
            {
                Console.Error.WriteLine("In the defined sequence " + sequence.Name
                                        + " the exec part \"" + sequence.XGRS
                                        + "\" caused the following error:\n");
                HandleSequenceParserException(ex);
                return(false);
            }

            // exact sequence definition compiled class
            source.Append("\n");

            if (sequence.Package != null)
            {
                source.AppendFrontFormat("namespace {0}\n", sequence.Package);
                source.AppendFront("{\n");
                source.Indent();
            }

            source.AppendFront("public class Sequence_" + sequence.Name + " : GRGEN_LIBGR.SequenceDefinitionCompiled\n");
            source.AppendFront("{\n");
            source.Indent();

            GenerateSequenceDefinedSingleton(source, sequence);

            source.Append("\n");
            GenerateGenericMethodReturnValues(source, sequence);

            source.Append("\n");
            GenerateInternalDefinedSequenceApplicationMethod(source, sequence, seq);

            source.Append("\n");
            GenerateExactExternalDefinedSequenceApplicationMethod(source, sequence);

            source.Append("\n");
            GenerateGenericExternalDefinedSequenceApplicationMethod(source, sequence);

            // end of exact sequence definition compiled class
            source.Unindent();
            source.AppendFront("}\n");

            if (sequence.Package != null)
            {
                source.Unindent();
                source.AppendFront("}\n");
            }

            return(true);
        }