コード例 #1
0
ファイル: SQLHelper.cs プロジェクト: ChiangHanLung/PIC_VDS
 public static void SQLWhere_SubStr(ref ArrayList ParameterList, DbType type, string FieldName, Object FieldValue, string Operator, string AndOr, int StartPos, int EndPos)
 {
     if (FieldValue.ToString().Trim() == "" || FieldValue.ToString().Trim() == "%%") return;
     ParameterItem pi = new ParameterItem();
     pi.ParaName = CheckParaName(ParameterList, FieldName);
     switch (type)
     {
         case DbType.String:
             pi.WhereString = string.Format(" {0} Substr({1},{4},{5}) {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StartPos.ToString(), EndPos.ToString());
             break;
         case DbType.Decimal:
             pi.WhereString = string.Format(" {0} Substr({1},{4},{5}) {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StartPos.ToString(), EndPos.ToString());
             break;
         case DbType.VarNumeric:
             pi.WhereString = string.Format(" {0} Substr({1},{4},{5}) {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StartPos.ToString(), EndPos.ToString());
             break;
         case DbType.DateTime:
             pi.WhereString = string.Format(" {0} Substr({1},{4},{5}) {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StartPos.ToString(), EndPos.ToString());
             FieldValue = string.Format("#{0}#", FieldValue.ToString());
             break;
     }
     pi.FieldName = FieldName;
     pi.FieldType = type;
     pi.FieldValue = FieldValue;
     ParameterList.Add(pi);
 }
コード例 #2
0
        public async Task <IEnumerable <ProjectItem> > GetProjects(string url = null)
        {
            try
            {
                if (url == null)
                {
                    url = this.MarketUrl;
                }
                string username = null;
                string project  = null;
                string target   = null;
                if (!this.GetRepoInfo(url, out username, out project, out target))
                {
                    XLogSys.Print.Error(GlobalHelper.Get("market_url_check"));
                    return(null);
                }

                IReadOnlyList <RepositoryContent> result = null;

                result = await client.Repository.Content.GetAllContents(username, project, target);

                var items = result?.Where(d => d.Type == ContentType.File && (d.Name.EndsWith(".xml", true, null) || d.Name.EndsWith(".hproj", true, null))).Select(
                    d =>
                {
                    var projectItem = new ProjectItem()
                    {
                        IsRemote = true,
                        SavePath = d.DownloadUrl
                    };
                    var suffix       = d.Name.Split('.').Last();
                    var name         = d.Name.Replace("." + suffix, "");
                    projectItem.Name = name;
                    var meta         = name + ".meta";
                    var metafile     = result.FirstOrDefault(d2 => d2.Name == meta);
                    if (metafile != null)
                    {
                        Task.Factory.StartNew(() =>
                        {
                            var response = WebRequest.Create(metafile.DownloadUrl).GetResponse().GetResponseStream();
                            using (StreamReader reader = new StreamReader(response, Encoding.UTF8))
                            {
                                var item     = reader.ReadToEnd();
                                var metainfo = ParameterItem.GetParameters(item);
                                ControlExtended.UIInvoke(() =>
                                {
                                    projectItem.DictDeserialize(metainfo.ToDictionary(d2 => d2.Key, d2 => (object)d2.Value));
                                });
                            }
                        });
                    }
                    return(projectItem);
                });
                return(items);
            }
            catch (Exception ex)
            {
                XLogSys.Print.Error(ex.Message);
                return(new List <ProjectItem>());
            }
        }
コード例 #3
0
ファイル: frmMain.cs プロジェクト: DOPCNQA/JsonFileUpdater
        private void ReadValueDataDele()
        {
            var path = $"{Environment.CurrentDirectory}\\ValueData.txt";

            var content = FileHelper.ReadFile(path);

            var list = content.Split(Environment.NewLine.ToCharArray());

            var result = "";
            var list1 = new List<ParameterItem>();
            foreach (string item in list)
            {
                if (item == "")
                    continue;
                var kv = new ParameterItem();
                kv.Id = Guid.NewGuid().ToString();
                kv.Group = "Value";
                kv.Name = "";
                kv.Value = item;
                list1.Add(kv);
            }

            ValueList = list1;

            this.BeginInvoke(new DeleParaObject(ReadValueDataAction), list1);

            base.EndExecute(null);
        }
コード例 #4
0
        public void SaveFile()
        {
            ParameterManager.Instance.DeviceName       = "BQ20Z45-R";
            ParameterManager.Instance.SMBusAddressSize = 1;
            ParameterManager.Instance.SMBusSpeed       = 10000;
            ParameterManager.Instance.SMBusAdapter     = "SIL CP2112";

            ParameterItem pi1 = new ParameterItem
            {
                Commmand     = 0,
                Name         = "ManufacturerAccess",
                Mode         = "R/W",
                Format       = "X4",
                Size         = 2,
                DefaultValue = "-",
                Unit         = "-",
            };

            ParameterItem pi2 = new ParameterItem
            {
                Commmand     = 0,
                Name         = "RemainingCapacityAlarm",
                Mode         = "R/W",
                Format       = "D5",
                Size         = 2,
                DefaultValue = "300",
                Unit         = "mAh",
            }
            ;

            ParameterManager.Instance.Parameters.Add(pi1);
            ParameterManager.Instance.Parameters.Add(pi2);

            ParameterManager.SaveFile(ParamFilePath);
        }
コード例 #5
0
ファイル: SQLHelper.cs プロジェクト: ChiangHanLung/PIC_VDS
 public static void SQLWhere_DateFormat(ref ArrayList ParameterList, DbType type, string FieldName, Object FieldValue, string Operator, string AndOr, string StringProvider)
 {
     if (FieldValue.ToString().Trim() == "" || FieldValue.ToString().Trim() == "%%" || type != DbType.DateTime) return;
     ParameterItem pi = new ParameterItem();
     pi.ParaName = ((FieldName.ToUpper() == "ROWNUM") ? "ROWNUM_1" : CheckParaName(ParameterList, FieldName));
     switch (type)
     {
         case DbType.String:
             pi.WhereString = string.Format(" {0} TO_CHAR({1},'{4}') {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StringProvider);
             break;
         case DbType.Decimal:
             pi.WhereString = string.Format(" {0} TO_CHAR({1},'{4}') {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StringProvider);
             break;
         case DbType.VarNumeric:
             pi.WhereString = string.Format(" {0} TO_CHAR({1},'{4}') {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StringProvider);
             break;
         case DbType.DateTime:
             pi.WhereString = string.Format(" {0} TO_CHAR({1},'{4}') {2} :{3}", AndOr, FieldName, Operator, pi.ParaName, StringProvider);
             break;
     }
     pi.FieldName = FieldName;
     pi.FieldType = DbType.String;
     pi.FieldValue = FieldValue;
     ParameterList.Add(pi);
 }
コード例 #6
0
 /// <summary>
 /// Checks specified parameter.
 /// </summary>
 private static void AssertParameter(
     string expectedName,
     int expectedLineNumber,
     ParameterItem parameter)
 {
     Assert.AreEqual(expectedName, parameter.Name);
     Assert.IsTrue(parameter.LineNumber.HasValue);
     Assert.AreEqual(expectedLineNumber, parameter.LineNumber);
 }
コード例 #7
0
 private void UpdateUserNameCandidates(ParameterItem currentItem)
 {
     _userNameBox.Items.Clear();
     _userNameBox.Items.AddRange(
         _historyItems.Where(item => item.TCPParameter.Destination == currentItem.TCPParameter.Destination)
         .Select(item => item.SSHParameter.Account)
         .Distinct()
         .OrderBy(s => s)
         .ToArray()
         );
 }
コード例 #8
0
        NetParam MapParameterItem(BaseDeclaration context, ParameterItem parameter, int index, bool isPinvoke, bool structsAndEnumsAreAlwaysRefs)
        {
            var theType = parameter.TypeSpec;             //parameter.IsInOut && !parameter.TypeSpec.IsInOut ? parameter.TypeSpec.WithInOutSet () : parameter.TypeSpec;
            var t       = MapType(context, theType, isPinvoke);

            if (isPinvoke)
            {
                t = RecastToReference(context, t, theType, structsAndEnumsAreAlwaysRefs);
            }
            return(ToNamedParam(parameter, t, index));
        }
コード例 #9
0
ファイル: BehaviorList.cs プロジェクト: TagsRocks/skill
 void _BtnRemove_Click(object sender, System.EventArgs e)
 {
     if (_LbItems.SelectedItem != null)
     {
         ParameterItem pi = (ParameterItem)_LbItems.SelectedItem;
         _Data.Remove(pi.Data);
         _LbItems.Items.Remove(pi);
         _LbItems.SelectedItem = null;
         this._OwnerListItem.UpdateContent();
     }
 }
コード例 #10
0
ファイル: SQLHelper.cs プロジェクト: ChiangHanLung/PIC_VDS
 public static void SQLWhere(ref ArrayList ParameterList, string FieldName, string ParaName, Object FieldValue, string Operator, string AndOr)
 {
     if (FieldValue.ToString().Trim() == "" || FieldValue.ToString().Trim() == "%%") return;
     ParameterItem pi = new ParameterItem();
     pi.ParaName = ParaName;
     pi.WhereString = string.Format(" {0} {1} {2} :{3}", AndOr, FieldName, Operator, pi.ParaName);
     pi.FieldName = FieldName;
     pi.FieldType = DbType.String;
     pi.FieldValue = FieldValue;
     ParameterList.Add(pi);
 }
コード例 #11
0
        public List <ParameterItem> RebuildParameterListWithGenericTypes(List <ParameterItem> pl)
        {
            var result = new List <ParameterItem> (pl.Count);

            foreach (var item in pl)
            {
                var newItem = new ParameterItem(item);
                newItem.TypeSpec = RebuildTypeWithGenericType(item.TypeSpec);
                result.Add(newItem);
            }
            return(result);
        }
コード例 #12
0
ファイル: SQLHelper.cs プロジェクト: ChiangHanLung/PIC_VDS
 public static void SQLWhere(ref ArrayList ParameterList, DbType type, string FieldName, Object FieldValue)
 {
     ParameterItem pi = new ParameterItem();
     pi.ParaName = CheckParaName(ParameterList, FieldName);
     pi.FieldName = FieldName;
     pi.FieldType = type;
     if (type != DbType.String)
     { pi.FieldValue = ((FieldValue == null || FieldValue.ToString() == "") ? null : FieldValue); }
     else
         pi.FieldValue = FieldValue;
     ParameterList.Add(pi);
 }
コード例 #13
0
        /// <summary>
        /// Apply specified parameters to the input controls.
        /// </summary>
        /// <param name="item">parameters to apply</param>
        private void ApplyParameters(ParameterItem item)
        {
            _portBox.Text = item.TCPParameter.Port.ToString();

            _encodingBox.SelectedItem  = item.TerminalSettings.Encoding;
            _localEchoBox.SelectedItem = item.TerminalSettings.LocalEcho;
            _newLineBox.SelectedItem   = item.TerminalSettings.TransmitNL;
            _telnetNewLine.Checked     =
                (item.TerminalSettings.TransmitNL == NewLine.CRLF) ? item.TelnetParameter.TelnetNewLine : false;
            _terminalTypeBox.SelectedItem = item.TerminalSettings.TerminalType;

            UpdateControlStatus();
        }
コード例 #14
0
 static bool TypeMatches(FunctionDeclaration decl, ParameterItem pi, SwiftType st, bool ignoreName, TypeMapper typeMap)
 {
     // some SwiftType parameters have no names, such as operators
     if (!ignoreName && pi.PublicName != "self" && st.Name != null && pi.PublicName != st.Name.Name)
     {
         return(false);
     }
     if (pi.IsVariadic != st.IsVariadic)
     {
         return(false);
     }
     return(TypeMatches(decl, pi.TypeSpec, st, typeMap));
 }
コード例 #15
0
        public static void SetInOutParam(DairyDateItem param)
        {
            InParam = new ParameterItem()
            {
                ParameterName  = @"Date",
                ParameterValue = param.Date
            };

            OutParam = new ParameterItem()
            {
                ParameterName  = @"result",
                ParameterValue = 0
            };
        }
コード例 #16
0
        /// <summary>
        /// Apply specified parameters to the input controls.
        /// </summary>
        /// <param name="item">parameters to apply</param>
        private void ApplyParameters(ParameterItem item)
        {
            UpdateUserNameCandidates(item);

            if (item.SSHParameter.Method == Granados.SSHProtocol.SSH1)
            {
                this._ssh1RadioButton.Checked = true;
            }
            else
            {
                this._ssh2RadioButton.Checked = true;
            }

            _portBox.Text             = item.TCPParameter.Port.ToString();
            _userNameBox.Text         = item.SSHParameter.Account;
            _authOptions.SelectedItem = item.SSHParameter.AuthenticationType.ToAuthType();
            _passphraseBox.Text       = item.SSHParameter.PasswordOrPassphrase;
            _privateKeyFile.Text      = item.SSHParameter.IdentityFileName;

            _encodingBox.SelectedItem     = item.TerminalSettings.Encoding;
            _localEchoBox.SelectedItem    = item.TerminalSettings.LocalEcho;
            _newLineBox.SelectedItem      = item.TerminalSettings.TransmitNL;
            _terminalTypeBox.SelectedItem = item.TerminalSettings.TerminalType;

            _useX11ForwardingCheckBox.Checked = item.SSHParameter.EnableX11Forwarding;

            if (item.SSHParameter.X11Forwarding != null)
            {
                _x11DisplayText.Text         = item.SSHParameter.X11Forwarding.Display.ToString();
                _x11ScreenText.Text          = item.SSHParameter.X11Forwarding.Screen.ToString();
                _x11NeedAuthCheckBox.Checked = item.SSHParameter.X11Forwarding.NeedAuth;
                _x11XauthorityText.Text      = item.SSHParameter.X11Forwarding.XauthorityFile;
                _x11UseCygwinDomainSocketCheckBox.Checked = item.SSHParameter.X11Forwarding.UseCygwinUnixDomainSocket;
                _x11CygwinX11UnixFolderText.Text          = item.SSHParameter.X11Forwarding.X11UnixFolder;
            }
            else
            {
                _x11DisplayText.Text         = "0";
                _x11ScreenText.Text          = "0";
                _x11NeedAuthCheckBox.Checked = false;
                _x11XauthorityText.Text      = "";
                _x11UseCygwinDomainSocketCheckBox.Checked = false;
                _x11CygwinX11UnixFolderText.Text          = "";
            }

            _useAgentForwardingCheckBox.Checked = item.SSHParameter.EnableAgentForwarding;

            UpdateControlStatus();
        }
コード例 #17
0
ファイル: BehaviorList.cs プロジェクト: TagsRocks/skill
                void _BtnAdd_Click(object sender, System.EventArgs e)
                {
                    ParameterData data = new ParameterData()
                    {
                        Name = "NewInt", Type = ParameterType.Int, Value = "0"
                    };

                    _Data.Add(data);
                    ParameterItem pi = new ParameterItem(_OwnerListItem, data);

                    _LbItems.Items.Add(pi);
                    _LbItems.SelectedItem = pi;

                    this._OwnerListItem.UpdateContent();
                }
コード例 #18
0
        private void AppendSubProperties(ref ParameterItem parameterItem, PropertyInfo propertyInfo)
        {
            var properties = propertyInfo.PropertyType.GetProperties();

            foreach (var property in properties)
            {
                ParameterItem subParameterItem      = new ParameterItem(property);
                var           serializableAttribute = property.PropertyType.GetCustomAttribute(typeof(SerializableAttribute));
                if (serializableAttribute == null && property.PropertyType != property.DeclaringType)
                {
                    AppendSubProperties(ref subParameterItem, property);
                }
                parameterItem.Properties.Add(subParameterItem);
            }
        }
コード例 #19
0
        public void Initialize()
        {
            string xmlFileContent = File.ReadAllText(options.XmlFilePath);
            Doc    docsAssembly   = Helpers.ParseXml(xmlFileContent);
            var    controllers    = Helpers.GetClasses(options.ProjectAssembly);
            List <ControllerItem> controllerItems = new List <ControllerItem>();

            foreach (var controller in controllers)
            {
                ControllerItem controllerItem = new ControllerItem(controller);
                controllerItem.Description = docsAssembly.Members.Member.FirstOrDefault(x => x.Name == $"T:{controller.Namespace}.{controller.Name}").Summary;
                controllerItem.Description = controllerItem.Description.Trim().Replace("\n", "");
                var actions = Helpers.GetMethods(controller);
                foreach (var action in actions)
                {
                    ActionItem actionItem    = new ActionItem(controllerItem, action);
                    string     actionXmlName = $"M:{controller.Namespace}.{controller.Name}.{action.Name}";
                    actionItem.Description = docsAssembly.Members.Member.FirstOrDefault(x => x.Name == actionXmlName)?.Summary;
                    actionXmlName         += "(";
                    var parameters = Helpers.GetParameters(action);
                    foreach (var parameter in parameters)
                    {
                        if (String.IsNullOrEmpty(actionItem.Description))
                        {
                            actionXmlName += parameter.ParameterType + ",";
                        }
                        bool          isVariable    = parameter.ParameterType.BaseType == typeof(ValueType);
                        ParameterItem parameterItem = new ParameterItem(parameter);
                        if (!isVariable)
                        {
                            AppendSubProperties(ref parameterItem, parameter);
                        }
                        actionItem.Parameters.Add(parameterItem);
                    }
                    if (String.IsNullOrEmpty(actionItem.Description))
                    {
                        actionXmlName          = actionXmlName.TrimEnd(',') + ")";
                        actionItem.Description = docsAssembly.Members.Member.FirstOrDefault(x => x.Name == actionXmlName)?.Summary;
                    }
                    actionItem.Description = actionItem.Description?.Trim().Replace("\n", "");
                    controllerItem.Actions.Add(actionItem);
                }
                controllerItems.Add(controllerItem);
            }
            options.DocumentWriter.WriteDocument(controllerItems);
        }
コード例 #20
0
        private static void CreateSample()
        {
            List <ParameterItem> paramList = new List <ParameterItem>();
            ParameterItem        param     = new ParameterItem
            {
                ShortParameter      = "i",
                LongParameter       = "input-file",
                VariableName        = "inputFile",
                Description         = "filename that contains the JSON values to drive the script.  command line overrides file",
                RequiresInputString = true,
                Default             = "", // this needs to be empty because if it is set, the script will try to find the file...
                RequiredParameter   = false,
                ValueIfSet          = "$2"
            };

            paramList.Add(param);
            param = new ParameterItem
            {
                LongParameter       = "log-directory",
                ShortParameter      = "l",
                Description         = "directory for the log file.  the log file name will be based on the script name",
                VariableName        = "logDirectory",
                Default             = "\"./\"",
                RequiresInputString = true,
                RequiredParameter   = false,
                ValueIfSet          = "$2"
            };
            paramList.Add(param);
            param = new ParameterItem
            {
                ShortParameter      = "d",
                Description         = "delete the resource group if it already exists",
                LongParameter       = "delete",
                VariableName        = "delete",
                Default             = "false",
                RequiresInputString = false,
                RequiredParameter   = false,
                ValueIfSet          = "true"
            };
            paramList.Add(param);
            ConfigModel model = new ConfigModel("test.sh", paramList, true, true, true, true);

            Console.WriteLine(model.Serialize());
        }
コード例 #21
0
 protected override void CreateCustomFileds()
 {
     base.CreateCustomFileds();
     _Item = (ParameterItem)Object;
     if (_Item.Data.Type == AnimationTreeParameterType.Float)
     {
         _FloatField               = new UI.FloatField();
         _FloatField.Label.text    = "Default Value";
         _FloatField.ValueChanged += _FloatField_ValueChanged;
         Controls.Add(_FloatField);
     }
     else
     {
         _IntField               = new UI.IntField();
         _IntField.Label.text    = "Default Value";
         _IntField.ValueChanged += _IntField_ValueChanged;
         Controls.Add(_IntField);
     }
 }
コード例 #22
0
 /// <summary>
 /// 获取接口数据
 /// </summary>
 /// <returns></returns>
 public Dictionary <string, DoTaskParameterItem> GetInterfaces()
 {
     if (TaskParameterItems.Count() != 0)
     {
         return(TaskParameterItems);
     }
     else
     {
         RouteAttribute classRoute = this.GetAttributeByClass <RouteAttribute>();
         string         rootPath   = classRoute.Url;
         var            methods    = this.GetType().GetMethods();
         methods.Foreach(m =>
         {
             var attributes = m.GetCustomAttributes().Where(a => a is RouteAttribute);
             if (attributes.Count() > 0)
             {
                 RouteAttribute route           = attributes.First() as RouteAttribute;
                 List <ParameterItem> paramters = new List <ParameterItem>();
                 m.GetParameters().Foreach(p =>
                 {
                     var it = new ParameterItem()
                     {
                         ParameterName = p.Name,
                     };
                     if (p.HasDefaultValue)
                     {
                         it.Value = p.DefaultValue.ToString();
                     }
                     paramters.Add(it);
                 });
                 this.TaskParameterItems.Add(rootPath + route.Url + string.Format("{0}", route.Explanation),
                                             new DoTaskParameterItem()
                 {
                     Paramters = paramters,
                     Url       = rootPath + route.Url,
                     Method    = m
                 });
             }
         });
         return(TaskParameterItems);
     }
 }
コード例 #23
0
        static void Main()
        {
            var cb = new ClassBuilder("EntryPoint", TypeAttributes.Public, false);
            var pi = new ParameterItem();

            pi.Name = "s";
            pi.Type = typeof(string);

            IStatementLine[] Statements = new IStatementLine[]
            {
                new ExpressionStatementLine(),
                new ReturnStatementLine()
            };

            var methodInvoke = new MethodInvokeExpressionLine();

            methodInvoke.MethodName = "WriteLine";
            var test = new TypeReferenceExpressionLine();

            test.Type = "System.Console";
            methodInvoke.TargetObject = test;
            var methodInvokeParam = new VariableReferenceExpressionLine();

            methodInvokeParam.VariableName = "s";
            methodInvoke.Parameters        = new IExpressionLine[] { methodInvokeParam };
            Statements[1].Expressions.Add(0, new VariableReferenceExpressionLine()
            {
                VariableName = "s"
            });
            Statements[0].Expressions.Add(0, methodInvoke);
            cb.AddMethod <string>("Print", new ParameterItem[] { pi }, MemberAttributes.Public | MemberAttributes.Static, Statements);

            var cub      = new CompileUnitBuilder("Bla");
            var typeDecl = cb.GetDeclaration();

            cub.AddClass(typeDecl);
            cub.PublishCode("c:\\Users\\Sytse\\Documents\\GitHubVisualStudio\\Minor_CodeGen\\CodeGen\\test.cs");

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new CodeGenStudio());
        }
コード例 #24
0
ファイル: frmMain.cs プロジェクト: DOPCNQA/JsonFileUpdater
        private void ReadDataDele(object obj)
        {
            var path = obj.ToString();
            var instanceSheetName = "Default";
            var commonSheetName = "Common";
            var temp = ExcelHelper.GetContentVertical(path, instanceSheetName);
            var temp1 = ExcelHelper.GetContent(path, commonSheetName);
            var list1 = new List<ParameterItem>();
            foreach (var item in temp1)
            {
                var kv = new ParameterItem();
                kv.Id = Guid.NewGuid().ToString();
                kv.Group = "Variable";
                kv.Name = item[0].Value;
                kv.Value = item[1].Value;
                list1.Add(kv);
            }


            foreach (var item in temp)
            {
                var kv = new ParameterItem();
                kv.Id = Guid.NewGuid().ToString();
                kv.Group = "Variable";
                kv.Name = item[0].Value;
                kv.Value = item[1].Value;
                list1.Add(kv);
            }

            this.ParameterList = list1;

            ExcelHelper.KillProcess();

            this.BeginInvoke(new DeleParaObject(ReadDataAction), list1);

            base.EndExecute(null);
        }
コード例 #25
0
        private void WriteText(DocWriter writer, AItem item)
        {
            string summary = string.Empty;

            void WriteNodes(IEnumerable <XNode> nodes)
            {
                foreach (XNode node in nodes)
                {
                    switch (node)
                    {
                    case XText text:
                        summary += string.Join("  \n", text.Value.Split('\n'));
                        break;

                    case XElement element:
                        switch (element.Name.LocalName)
                        {
                        case "see":
                        case "seealso":
                            string referenceName = element.GetReferenceName();
                            summary +=
                                _items.TryGetValue(referenceName, out AMemberItem reference)
                                        ? (reference is NamespaceItem ? reference.AsLinkWithTarget(_mainName) : reference.AsLink())
                                        : referenceName.Substring(2).AsDotNetApiLink();
                            break;

                        case "typeparamref":
                            AMemberItem parent  = item as AMemberItem ?? item.Parent;
                            GenericItem generic = null;
                            while (parent != null && generic == null)
                            {
                                if (parent is AGenericDocItem genericItem)
                                {
                                    generic = Array.Find(genericItem.Generics, i => i.Name == element.GetName());
                                }

                                parent = parent.Parent;
                            }

                            if (generic == null)
                            {
                                summary += element.GetName();
                            }
                            else
                            {
                                summary +=
                                    writer.IsForThis(generic.Parent)
                                            ? generic.AsPageLink()
                                            : generic.AsLinkWithTarget();
                            }
                            break;

                        case "paramref":
                            IParameterDocItem parameterItem = (item as IParameterDocItem) ?? (item.Parent as IParameterDocItem);
                            ParameterItem     parameter     = parameterItem.Parameters.First(i => i.Name == element.GetName());

                            summary += parameter.AsPageLink();
                            break;

                        case "c":
                            summary += $"`{element.Value}`";
                            break;

                        case "code":
                            summary += $"```{element.Value}```\n";
                            break;

                        case "para":
                            summary += "\n\n";
                            WriteNodes(element.Nodes());
                            summary += "\n\n";
                            break;

                        default:
                            summary += element.ToString();
                            break;
                        }
                        break;

                    default:
                        throw new Exception($"unhandled node type in summary {node.NodeType}");
                    }
                }
            }

            WriteNodes(item.Summary.Nodes());

            string[] lines      = summary.Split('\n');
            int      startIndex = 0;
            int      firstLine  = 0;

            foreach (string line in lines)
            {
                if (!string.IsNullOrWhiteSpace(line))
                {
                    startIndex = line.Length - line.TrimStart().Length;
                    break;
                }

                ++firstLine;
            }

            summary = string.Join(Environment.NewLine, lines.Skip(firstLine).Select(l => l.StartsWith(" ") ? l.Substring(startIndex) : l));
            while (summary.EndsWith(Environment.NewLine))
            {
                summary = summary.Substring(0, summary.Length - Environment.NewLine.Length);
            }

            writer.WriteLine($"{summary.TrimEnd()}");
        }
コード例 #26
0
 public ParameterItemProperties(ParameterItem item)
     : base(item)
 {
     _Item = item;
 }
コード例 #27
0
        private void Add(AnimationTreeParameter data)
        {
            ParameterItem item = new ParameterItem(this, data);

            _ParameterList.Items.Add(item);
        }
コード例 #28
0
ファイル: Signature.cs プロジェクト: pminiszewski/HlslTools
 private Parameter CreateParameter(ParameterItem p)
 {
     return new Parameter(this, p.Name, p.Documentation, new Span(p.Span.Start, p.Span.Length));
 }
コード例 #29
0
        /// <summary>
        /// AddFilter
        /// </summary>
        /// <typeparam name="TFilter"></typeparam>
        public void AddFilter <TFilter>()
            where TFilter : TFilterBase
        {
            MethodInfo[] methods = typeof(TFilter)
                                   .GetMethods()
                                   .Where(x => x.IsPublic)
                                   .Where(x => x.GetCustomAttribute <FilterAttribute>() != null)
                                   .ToArray();

            foreach (MethodInfo method in methods)
            {
                ParameterInfo[] parameters = method.GetParameters();

                Type[] integerTypes        = new Type[] { typeof(byte), typeof(short), typeof(int), typeof(long) };
                Type[] floatingNumberTypes = new Type[] { typeof(float), typeof(double), typeof(decimal) };

                ParameterItem CreateParameter(ParameterInfo pi, string pattern)
                {
                    return(new ParameterItem()
                    {
                        Name = pi.Name, Pattern = $@"(?<{pi.Name}>{pattern})"
                    });
                }

                List <ParameterItem> pp = new List <ParameterItem>();

                for (int i = 0; i < parameters.Length; i++)
                {
                    ParameterInfo currentParameter = parameters[i];

                    if (integerTypes.Any(x => x == currentParameter.ParameterType))
                    {
                        pp.Add(CreateParameter(currentParameter, @"-?\d+"));
                    }
                    else if (floatingNumberTypes.Any(x => x == currentParameter.ParameterType))
                    {
                        pp.Add(CreateParameter(currentParameter, @"-?\d+\.\d+"));
                    }
                    else if (currentParameter.ParameterType == typeof(bool))
                    {
                        pp.Add(CreateParameter(parameters[i], "True|False"));
                    }
                    else if (currentParameter.ParameterType == typeof(string))
                    {
                        ParameterItem p = CreateParameter(parameters[i], "[^']*");

                        p.Pattern = $"'{p.Pattern}'";

                        pp.Add(p);
                    }
                    else if (currentParameter.ParameterType.IsEnum)
                    {
                        //@"[a-z]{1}[a-z0-9]*"

                        string[] enumValues = Enum.GetNames(parameters[i].ParameterType)
                                              .Select(x => x.ToLower())
                                              .ToArray();

                        pp.Add(CreateParameter(parameters[i], string.Join("|", enumValues)));
                    }
                    else
                    {
                        throw new Exception("parameter type is not supported: " + parameters[i].ParameterType.Name);
                    }
                }

                StringBuilder builder = new StringBuilder("^");

                //function begin
                builder.Append($@"{method.Name.ToLowerInvariant()}\(");

                bool optionalParmeterCall = parameters.All(x => (x.DefaultValue is DBNull) == false);

                if (optionalParmeterCall)
                {
                    //add optional parameters
                    builder.Append($"(,|{string.Join("|", pp.Select(x => $"({x.Name}={x.Pattern})").ToArray())})*");
                }
                else
                {
                    //add all parameters
                    builder.Append(string.Join(",", pp.Select(x => x.Pattern).ToArray()));
                }

                //function end
                builder.Append(@"\)$");

                IFilterAction filterAction = CreateFilterAction <TFilter>(new Regex(builder.ToString(), RegexOptions.Compiled), method);

                FilterActions.Add(filterAction);
            }
        }
コード例 #30
0
 /// <summary>
 /// Checks specified parameter.
 /// </summary>
 private static void AssertParameter(
     string expectedName,
     int expectedLineNumber,
     ParameterItem parameter)
 {
     Assert.AreEqual(expectedName, parameter.Name);
     Assert.IsTrue(parameter.LineNumber.HasValue);
     Assert.AreEqual(expectedLineNumber, parameter.LineNumber);
 }
コード例 #31
0
        private static void RunScript(string script, string[] args)
        {
            lock (psLocker)
            {
                powershellHost   = new Host();
                powershellEngine = System.Management.Automation.PowerShell.Create();
            }

            try
            {
                InitialSessionState initalState = InitialSessionState.CreateDefault();

                List <ParameterItem> validCmds = new List <ParameterItem>();
                //AddValidCommands

                Commandline cmdLine = new Commandline(args);

                if (cmdLine["help"] == "true" || cmdLine["?"] == "true")
                {
                    AssemblyData assInfo = new AssemblyData(System.Reflection.Assembly.GetExecutingAssembly());

                    StringBuilder outputBuilder = new StringBuilder();
                    outputBuilder.AppendLine();
                    outputBuilder.AppendLine(string.Format("{0} v{1} by {2}", assInfo.Product, assInfo.Version, assInfo.Company));
                    outputBuilder.AppendLine(assInfo.Copyright);
                    outputBuilder.AppendLine();
                    outputBuilder.AppendLine(" [-Help]");
                    outputBuilder.AppendLine("    Show help");

                    foreach (ParameterItem cmdName in validCmds)
                    {
                        if (cmdName.Mandatory)
                        {
                            outputBuilder.AppendLine(string.Format(" -{0} <{1}>", cmdName.Name, cmdName.Type));
                        }
                        else
                        {
                            outputBuilder.AppendLine(string.Format(" [-{0} <{1}>]", cmdName.Name, cmdName.Type));
                        }

                        if (!string.IsNullOrWhiteSpace(cmdName.HelpText))
                        {
                            outputBuilder.AppendLine(string.Format("    {0}", cmdName.HelpText));
                        }
                    }

                    if (hideCon)
                    {
                        MessageBox.Show(outputBuilder.ToString(), "Help", MessageBoxButtons.OK, MessageBoxIcon.Question);
                    }
                    else
                    {
                        ConsoleHandler.WriteLine(outputBuilder.ToString());
                    }

                    return;
                }

                Dictionary <string, object> cmdLineArgs = new Dictionary <string, object>();
                foreach (string arg in cmdLine.GetKeys())
                {
                    ParameterItem paramItem = validCmds.FirstOrDefault(x => String.Equals(x.Name, arg, StringComparison.CurrentCultureIgnoreCase));

                    if (paramItem != null)
                    {
                        try
                        {
                            object realItem;
                            switch (paramItem.Type)
                            {
                            case "sbyte":
                                realItem = sbyte.Parse(cmdLine[arg]);
                                break;

                            case "byte":
                                realItem = byte.Parse(cmdLine[arg]);
                                break;

                            case "short":
                                realItem = short.Parse(cmdLine[arg]);
                                break;

                            case "ushort":
                                realItem = ushort.Parse(cmdLine[arg]);
                                break;

                            case "int":
                                realItem = int.Parse(cmdLine[arg]);
                                break;

                            case "uint":
                                realItem = uint.Parse(cmdLine[arg]);
                                break;

                            case "ulong":
                                realItem = ulong.Parse(cmdLine[arg]);
                                break;

                            case "long":
                                realItem = long.Parse(cmdLine[arg]);
                                break;

                            case "float":
                                realItem = float.Parse(cmdLine[arg]);
                                break;

                            case "double":
                                realItem = double.Parse(cmdLine[arg]);
                                break;

                            case "decimal":
                                realItem = decimal.Parse(cmdLine[arg]);
                                break;

                            case "char":
                                realItem = char.Parse(cmdLine[arg]);
                                break;

                            case "switch":
                            case "bool":
                                realItem = bool.Parse(cmdLine[arg]);
                                break;

                            case "boolean":
                                realItem = Boolean.Parse(cmdLine[arg]);
                                break;

                            default:
                                realItem = cmdLine[arg];
                                break;
                            }

                            cmdLineArgs.Add(arg, realItem);
                        }
                        catch (Exception)
                        {
                            string errorString = string.Format("Parameter '-{0}' was not in correct format: '{1}'", arg, paramItem.Type);

                            if (hideCon)
                            {
                                MessageBox.Show(errorString, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                            else
                            {
                                ConsoleHandler.WriteLine(errorString);
                            }

                            return;
                        }
                    }
                    else
                    {
                        StringBuilder outputBuilder = new StringBuilder();
                        outputBuilder.AppendLine(string.Format("Parameter '-{0}' is not valid. Use '-help' to show valid parameters.", arg));

                        if (hideCon)
                        {
                            MessageBox.Show(outputBuilder.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                        else
                        {
                            ConsoleHandler.WriteLine(outputBuilder.ToString());
                        }

                        return;
                    }
                }

                foreach (ParameterItem paramItem in validCmds.Where(x => x.Mandatory == true))
                {
                    if (!cmdLineArgs.ContainsKey(paramItem.Name.ToLower()))
                    {
                        StringBuilder outputBuilder = new StringBuilder();
                        outputBuilder.AppendLine(string.Format("Parameter '-{0}' of type '{1}' is mandatory.", paramItem.Name, paramItem.Type));

                        if (hideCon)
                        {
                            MessageBox.Show(outputBuilder.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                        else
                        {
                            ConsoleHandler.WriteLine(outputBuilder.ToString());
                        }

                        return;
                    }
                }

                List <string> modulesToLoad = Common.ProcessManifest(initalState);

                powershellEngine.Runspace = RunspaceFactory.CreateRunspace(powershellHost, initalState);
                powershellEngine.Runspace.ApartmentState = System.Threading.ApartmentState.MTA;
                powershellEngine.Runspace.Open();

                RunspaceInvoke runSpaceInvoker = new RunspaceInvoke(powershellEngine.Runspace);

                try
                {
                    runSpaceInvoker.Invoke("Set-ExecutionPolicy Unrestricted -Scope Process");
                }
                catch
                {
                }

                foreach (string module in modulesToLoad)
                {
                    try
                    {
                        runSpaceInvoker.Invoke(string.Format("Import-Module {0} -Scope Global", module));
                    }
                    catch (Exception e)
                    {
                        ConsoleHandler.WriteLine(string.Format("Could import module {0}: {0}", e.Message, module));
                    }
                }

                Pipeline pipeline = powershellEngine.Runspace.CreatePipeline();
                Command  command  = new Command(script, true, true);

                foreach (KeyValuePair <string, object> cmdLineData in cmdLineArgs)
                {
                    command.Parameters.Add(cmdLineData.Key, cmdLineData.Value);
                }

                pipeline.Commands.Add(command);
                Collection <PSObject> resultObjects = pipeline.Invoke();

                foreach (PSObject resultObject in resultObjects)
                {
                    ConsoleHandler.WriteLine(resultObject.ToString());
                }
            }
            catch (Exception e)
            {
                ConsoleHandler.WriteLine(string.Format("Internal error: {0}", e.Message));
            }
            finally
            {
                lock (psLocker)
                {
                    powershellEngine.Dispose();
                    powershellEngine = null;
                }
            }
        }
コード例 #32
0
ファイル: BehaviorList.cs プロジェクト: TagsRocks/skill
                public ParameterDifinitionEditor(ListItem owner, ParameterDataCollection data)
                {
                    this._OwnerListItem = owner;
                    this._Data          = data;
                    this.RowDefinitions.Add(24, GridUnitType.Pixel); // title
                    this.RowDefinitions.Add(18, GridUnitType.Pixel); // header
                    this.RowDefinitions.Add(1, GridUnitType.Star);   // items
                    this.RowDefinitions.Add(20, GridUnitType.Pixel); // buttons

                    Skill.Editor.UI.DropShadowLabel title = new UI.DropShadowLabel()
                    {
                        Text = "Parameter Difinition", Height = 20, Margin = new Thickness(0, 0, 0, 4)
                    };
                    this.Controls.Add(title);

                    _HeaderBg = new Box()
                    {
                        Row = 1, Style = (GUIStyle)"RL Header"
                    };
                    this.Controls.Add(_HeaderBg);
                    _Header = new Grid()
                    {
                        Row = 1
                    };
                    _Header.ColumnDefinitions.Add(1, GridUnitType.Star);
                    _Header.ColumnDefinitions.Add(2, GridUnitType.Star);
                    _Header.ColumnDefinitions.Add(2, GridUnitType.Star);
                    _Header.Controls.Add(new Label()
                    {
                        Column = 0, Text = "Type"
                    });
                    _Header.Controls.Add(new Label()
                    {
                        Column = 1, Text = "Name"
                    });
                    _Header.Controls.Add(new Label()
                    {
                        Column = 2, Text = "Default Value"
                    });
                    this.Controls.Add(_Header);


                    _LbItems = new Framework.UI.ListBox()
                    {
                        Row = 2
                    };
                    _LbItems.DisableFocusable();
                    _LbItems.BackgroundVisible = true;
                    _LbItems.Background.Style  = (GUIStyle)"RL Background";
                    this.Controls.Add(_LbItems);

                    _PnlButtons = new Grid()
                    {
                        Row = 3
                    };
                    _PnlButtons.ColumnDefinitions.Add(1, GridUnitType.Star);
                    _PnlButtons.ColumnDefinitions.Add(20, GridUnitType.Pixel); // btn add
                    _PnlButtons.ColumnDefinitions.Add(20, GridUnitType.Pixel); // btn remove
                    this.Controls.Add(_PnlButtons);

                    _BtnAdd = new Button {
                        Column = 1
                    };
                    _PnlButtons.Controls.Add(_BtnAdd);

                    _BtnRemove = new Button()
                    {
                        Column = 2, IsEnabled = false
                    };
                    _PnlButtons.Controls.Add(_BtnRemove);

                    _LbItems.SelectionChanged += _LbItems_SelectionChanged;
                    _BtnAdd.Click             += _BtnAdd_Click;
                    _BtnRemove.Click          += _BtnRemove_Click;

                    for (int i = 0; i < _Data.Count; i++)
                    {
                        ParameterItem item = new ParameterItem(_OwnerListItem, _Data[i]);
                        _LbItems.Items.Add(item);
                    }
                }
コード例 #33
0
        static NetParam ToNamedParam(ParameterItem st, NetTypeBundle bundle, int index)
        {
            string targetName = ComeUpWithAName(st.NameIsRequired ? st.PublicName : st.PrivateName, bundle.Type, index);

            return(new NetParam(targetName, bundle));
        }
コード例 #34
0
        public SLParameter ToParameter(TypeMapper typeMapper, FunctionDeclaration func, SLImportModules modules, ParameterItem p, int index,
                                       bool dontChangeInOut, SLGenericTypeDeclarationCollection genericDecl = null, bool remapSelf = false, string remappedSelfName = "")
        {
            var pIsGeneric     = func.IsTypeSpecGeneric(p) && p.TypeSpec is NamedTypeSpec;
            var parmTypeEntity = !pIsGeneric?typeMapper.GetEntityForTypeSpec(p.TypeSpec) : null;

            if (parmTypeEntity == null && !pIsGeneric && p.IsInOut)
            {
                throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 45, $"In function {func.ToFullyQualifiedName ()}, unknown type parameter type {p.PublicName}:{p.TypeName}.");
            }
            var    parmKind = p.IsInOut && (pIsGeneric || !parmTypeEntity.IsStructOrEnum) ? SLParameterKind.InOut : SLParameterKind.None;
            SLType parmType = null;

            var pTypeSpec = remapSelf ? p.TypeSpec.ReplaceName("Self", remappedSelfName) : p.TypeSpec;

            if (genericDecl != null)
            {
                GatherGenerics(typeMapper, func, modules, pTypeSpec, genericDecl);
            }
            if (pIsGeneric)
            {
                if (pTypeSpec.ContainsGenericParameters)
                {
                    var ns       = pTypeSpec as NamedTypeSpec;
                    var boundGen = new SLBoundGenericType(ns.Name,
                                                          pTypeSpec.GenericParameters.Select(genParm => {
                        return(MapType(func, modules, genParm, true));
                    }));
                    if (parent.MustForcePassByReference(func, ns))
                    {
                        boundGen = new SLBoundGenericType("UnsafeMutablePointer", boundGen);
                    }
                    parmType = boundGen;
                }
                else
                {
                    var namedType = pTypeSpec as NamedTypeSpec;
                    if (namedType == null)
                    {
                        throw new NotImplementedException("Can only have a named type spec here.");
                    }
                    var depthIndex = func.GetGenericDepthAndIndex(namedType.Name);
                    var gd         = func.GetGeneric(depthIndex.Item1, depthIndex.Item2);
                    var genRef     = new SLGenericReferenceType(depthIndex.Item1, depthIndex.Item2);
                    parmType = genRef;
                }
            }
            else
            {
                parmType = MapType(func, modules, pTypeSpec, false);
                if (pIsGeneric)
                {
                    Tuple <int, int> depthIndex = func.GetGenericDepthAndIndex(pTypeSpec);
                    parmType = new SLGenericReferenceType(depthIndex.Item1, depthIndex.Item2);
                }
                else if (parent.MustForcePassByReference(func, pTypeSpec) && !dontChangeInOut)
                {
                    parmType = new SLBoundGenericType(p.IsInOut ? "UnsafeMutablePointer" : "UnsafePointer", parmType);
                }
            }
            if (isForOverride && p.IsVariadic)
            {
                // if we get here, then parmType is an SLSimpleType of SwiftArray<someType>
                // we're going to turn it into "someType ..."
                var oldParmType = parmType as SLBoundGenericType;
                parmType = new SLVariadicType(oldParmType.BoundTypes [0]);
            }
            var publicName  = !p.NameIsRequired ? null : ConjureIdentifier(p.PublicName, index);
            var privateName = !String.IsNullOrEmpty(p.PrivateName) ? p.PrivateName : null;

            return(new SLParameter(publicName, ConjureIdentifier(privateName, index), parmType, parmKind));
        }
コード例 #35
0
 SLParameter ToParameterToCSharpTypes(SLImportModules modules, ParameterItem p, int index)
 {
     return(new SLParameter(p.PublicName, p.PrivateName, MapTypeSimplified(modules, p.TypeSpec),
                            p.IsInOut && TypeSpec.IsBuiltInValueType(p.TypeSpec) ? SLParameterKind.InOut : SLParameterKind.None));
 }
コード例 #36
0
        private static void CreateSample()
        {
            List <ParameterItem> paramList = new List <ParameterItem>();
            ParameterItem        param     = new ParameterItem
            {
                ShortParameter      = "i",
                LongParameter       = "input-file",
                VariableName        = "inputFile",
                Description         = "filename that contains the JSON values to drive the script.  command line overrides file",
                RequiresInputString = true,
                Default             = "", // this needs to be empty because if it is set, the script will try to find the file...
                RequiredParameter   = false,
                ValueIfSet          = "$2"
            };

            paramList.Add(param);
            param = new ParameterItem
            {
                LongParameter       = "log-directory",
                ShortParameter      = "l",
                Description         = "directory for the log file.  the log file name will be based on the script name",
                VariableName        = "logDirectory",
                Default             = "\"./\"",
                RequiresInputString = true,
                RequiredParameter   = false,
                ValueIfSet          = "$2"
            };
            paramList.Add(param);


            param = new ParameterItem()
            {
                LongParameter       = "create",
                ShortParameter      = "c",
                VariableName        = "create",
                Description         = "creates the resource",
                RequiresInputString = false,
                Default             = "false",
                RequiredParameter   = false,
                ValueIfSet          = "true"
            };

            param = new ParameterItem()
            {
                LongParameter       = "verify",
                ShortParameter      = "v",
                VariableName        = "verify",
                Description         = "verifies the script ran correctly",
                RequiresInputString = false,
                Default             = "false",
                RequiredParameter   = false,
                ValueIfSet          = "true"
            };
            paramList.Add(param);
            param = new ParameterItem()
            {
                LongParameter       = "delete",
                ShortParameter      = "d",
                VariableName        = "delete",
                Description         = "deletes whatever the script created",
                RequiresInputString = false,
                Default             = "false",
                RequiredParameter   = false,
                ValueIfSet          = "true"
            };
            paramList.Add(param);

            ScriptData model = new ScriptData("test.sh", paramList, true, true, true, "Sample test script", "");

            Console.WriteLine(model.ToJson());
        }