public ListStatusRequest(
         QuickFix.Fields.ListID aListID
     )
     : this()
 {
     this.ListID = aListID;
 }
Example #2
1
 public TestRequest(
         QuickFix.Fields.TestReqID aTestReqID
     )
     : this()
 {
     this.TestReqID = aTestReqID;
 }
 public TradingSessionStatusRequest(
   QuickFix.TradSesReqID aTradSesReqID,
   QuickFix.SubscriptionRequestType aSubscriptionRequestType )
 : base(MsgType()) {
   set(aTradSesReqID);
   set(aSubscriptionRequestType);
 }
 public TradeCaptureReportRequest(
   QuickFix.TradeRequestID aTradeRequestID,
   QuickFix.TradeRequestType aTradeRequestType )
 : base(MsgType()) {
   set(aTradeRequestID);
   set(aTradeRequestType);
 }
 public SecurityDefinitionRequest(
   QuickFix.SecurityReqID aSecurityReqID,
   QuickFix.SecurityRequestType aSecurityRequestType )
 : base(MsgType()) {
   set(aSecurityReqID);
   set(aSecurityRequestType);
 }
 public CollateralInquiryAck(
   QuickFix.CollInquiryID aCollInquiryID,
   QuickFix.CollInquiryStatus aCollInquiryStatus )
 : base(MsgType()) {
   set(aCollInquiryID);
   set(aCollInquiryStatus);
 }
Example #7
1
 public QuoteRequest(
         QuickFix.Fields.QuoteReqID aQuoteReqID
     )
     : this()
 {
     this.QuoteReqID = aQuoteReqID;
 }
 public SettlementInstructionRequest(
   QuickFix.SettlInstReqID aSettlInstReqID,
   QuickFix.TransactTime aTransactTime )
 : base(MsgType()) {
   set(aSettlInstReqID);
   set(aTransactTime);
 }
 public MarketDefinitionUpdateReport(
   QuickFix.MarketReportID aMarketReportID,
   QuickFix.MarketID aMarketID )
 : base(MsgType()) {
   set(aMarketReportID);
   set(aMarketID);
 }
 public CollateralReport(
   QuickFix.CollRptID aCollRptID,
   QuickFix.CollStatus aCollStatus )
 : base(MsgType()) {
   set(aCollRptID);
   set(aCollStatus);
 }
 public ApplicationMessageRequestAck(
         QuickFix.Fields.ApplResponseID aApplResponseID
     )
     : this()
 {
     this.ApplResponseID = aApplResponseID;
 }
Example #12
1
 public AssignmentReport(
         QuickFix.Fields.AsgnRptID aAsgnRptID,
         QuickFix.Fields.AccountType aAccountType,
         QuickFix.Fields.SettlPrice aSettlPrice,
         QuickFix.Fields.SettlPriceType aSettlPriceType,
         QuickFix.Fields.UnderlyingSettlPrice aUnderlyingSettlPrice,
         QuickFix.Fields.AssignmentMethod aAssignmentMethod,
         QuickFix.Fields.OpenInterest aOpenInterest,
         QuickFix.Fields.ExerciseMethod aExerciseMethod,
         QuickFix.Fields.SettlSessID aSettlSessID,
         QuickFix.Fields.SettlSessSubID aSettlSessSubID,
         QuickFix.Fields.ClearingBusinessDate aClearingBusinessDate
     ) : this()
 {
     this.AsgnRptID = aAsgnRptID;
     this.AccountType = aAccountType;
     this.SettlPrice = aSettlPrice;
     this.SettlPriceType = aSettlPriceType;
     this.UnderlyingSettlPrice = aUnderlyingSettlPrice;
     this.AssignmentMethod = aAssignmentMethod;
     this.OpenInterest = aOpenInterest;
     this.ExerciseMethod = aExerciseMethod;
     this.SettlSessID = aSettlSessID;
     this.SettlSessSubID = aSettlSessSubID;
     this.ClearingBusinessDate = aClearingBusinessDate;
 }
Example #13
1
 public QuoteRequestReject(
   QuickFix.QuoteReqID aQuoteReqID,
   QuickFix.QuoteRequestRejectReason aQuoteRequestRejectReason )
 : base(MsgType()) {
   set(aQuoteReqID);
   set(aQuoteRequestRejectReason);
 }
Example #14
1
 public TradeCaptureReport(
   QuickFix.LastQty aLastQty,
   QuickFix.LastPx aLastPx )
 : base(MsgType()) {
   set(aLastQty);
   set(aLastPx);
 }
Example #15
1
 public ListExecute(
   QuickFix.ListID aListID,
   QuickFix.TransactTime aTransactTime )
 : base(MsgType()) {
   set(aListID);
   set(aTransactTime);
 }
Example #16
1
 public Confirmation(
         QuickFix.Fields.ConfirmID aConfirmID,
         QuickFix.Fields.ConfirmTransType aConfirmTransType,
         QuickFix.Fields.ConfirmType aConfirmType,
         QuickFix.Fields.ConfirmStatus aConfirmStatus,
         QuickFix.Fields.TransactTime aTransactTime,
         QuickFix.Fields.TradeDate aTradeDate,
         QuickFix.Fields.AllocQty aAllocQty,
         QuickFix.Fields.Side aSide,
         QuickFix.Fields.AllocAccount aAllocAccount,
         QuickFix.Fields.AvgPx aAvgPx,
         QuickFix.Fields.GrossTradeAmt aGrossTradeAmt,
         QuickFix.Fields.NetMoney aNetMoney
     )
     : this()
 {
     this.ConfirmID = aConfirmID;
     this.ConfirmTransType = aConfirmTransType;
     this.ConfirmType = aConfirmType;
     this.ConfirmStatus = aConfirmStatus;
     this.TransactTime = aTransactTime;
     this.TradeDate = aTradeDate;
     this.AllocQty = aAllocQty;
     this.Side = aSide;
     this.AllocAccount = aAllocAccount;
     this.AvgPx = aAvgPx;
     this.GrossTradeAmt = aGrossTradeAmt;
     this.NetMoney = aNetMoney;
 }
Example #17
1
 public Quote(
   QuickFix.QuoteID aQuoteID,
   QuickFix.Symbol aSymbol )
 : base(MsgType()) {
   set(aQuoteID);
   set(aSymbol);
 }
Example #18
1
 public Email(
         QuickFix.Fields.EmailType aEmailType
     )
     : this()
 {
     this.EmailType = aEmailType;
 }
Example #19
1
 public TradingSessionStatus(
   QuickFix.TradingSessionID aTradingSessionID,
   QuickFix.TradSesStatus aTradSesStatus )
 : base(MsgType()) {
   set(aTradingSessionID);
   set(aTradSesStatus);
 }
 public BusinessMessageReject(
   QuickFix.RefMsgType aRefMsgType,
   QuickFix.BusinessRejectReason aBusinessRejectReason )
 : base(MsgType()) {
   set(aRefMsgType);
   set(aBusinessRejectReason);
 }
 public DerivativeSecurityList(
         QuickFix.Fields.SecurityResponseID aSecurityResponseID
     )
     : this()
 {
     this.SecurityResponseID = aSecurityResponseID;
 }
Example #22
1
 public PositionReport(
   QuickFix.PosMaintRptID aPosMaintRptID,
   QuickFix.ClearingBusinessDate aClearingBusinessDate )
 : base(MsgType()) {
   set(aPosMaintRptID);
   set(aClearingBusinessDate);
 }
Example #23
1
 public News(
         QuickFix.Fields.Headline aHeadline
     )
     : this()
 {
     this.Headline = aHeadline;
 }
 public NetworkCounterpartySystemStatusResponse(
   QuickFix.NetworkStatusResponseType aNetworkStatusResponseType,
   QuickFix.NetworkResponseID aNetworkResponseID )
 : base(MsgType()) {
   set(aNetworkStatusResponseType);
   set(aNetworkResponseID);
 }
 public MarketDataSnapshotFullRefresh(
         QuickFix.Fields.Symbol aSymbol
     )
     : this()
 {
     this.Symbol = aSymbol;
 }
 public PartyDetailsListRequest(
         QuickFix.Fields.PartyDetailsListRequestID aPartyDetailsListRequestID
     )
     : this()
 {
     this.PartyDetailsListRequestID = aPartyDetailsListRequestID;
 }
Example #27
0
        private void AddItems(ICollection items, TreeNodeCollection parent, bool topLevel)
        {
            foreach (object o in items)
            {
                if (o is QuickFix)
                {
                    QuickFix qf   = (QuickFix)o;
                    string   text = qf.SubText;
                    if (topLevel)
                    {
                        text = string.Format("{0} '{1}'", qf.MainText, qf.SubText);
                    }

                    TreeNode tnSub = new TreeNode(text);
                    parent.Add(tnSub);
                    tnSub.Tag                = qf;
                    tnSub.ImageIndex         = 2;
                    tnSub.SelectedImageIndex = 2;
                }
                else
                {
                    // must be group
                    QuickFixGroup qfg    = (QuickFixGroup)o;
                    TreeNode      tnMain = new TreeNode(qfg.Name);
                    parent.Add(tnMain);
                    tnMain.ImageIndex         = 1;
                    tnMain.SelectedImageIndex = 1;
                    AddItems(qfg.Items, tnMain.Nodes, false);
                    if (topLevel)
                    {
                        tnMain.Expand();
                    }
                }
            }
        }
Example #28
0
        public void QuickFix_ZeroBased()
        {
            Configuration.ZeroBasedIndices = true;

            var input = new QuickFix()
            {
                Line      = 0,
                Column    = 0,
                EndLine   = 19,
                EndColumn = 23
            };

            var json = JsonConvert.SerializeObject(input, Formatting.Indented);

            const string output = @"
{
  ""FileName"": null,
  ""Line"": 0,
  ""Column"": 0,
  ""EndLine"": 19,
  ""EndColumn"": 23,
  ""Text"": null,
  ""Projects"": []
}
";

            Assert.Equal(output.Trim(), json);
        }
Example #29
0
 public MassQuote(
         QuickFix.Fields.QuoteID aQuoteID
     )
     : this()
 {
     this.QuoteID = aQuoteID;
 }
Example #30
0
 public SecurityStatus(
         QuickFix.Fields.Symbol aSymbol
     )
     : this()
 {
     this.Symbol = aSymbol;
 }
Example #31
0
 public ExecutionReport(
         QuickFix.Fields.OrderID aOrderID,
         QuickFix.Fields.ExecID aExecID,
         QuickFix.Fields.ExecTransType aExecTransType,
         QuickFix.Fields.ExecType aExecType,
         QuickFix.Fields.OrdStatus aOrdStatus,
         QuickFix.Fields.Symbol aSymbol,
         QuickFix.Fields.Side aSide,
         QuickFix.Fields.OrderQty aOrderQty,
         QuickFix.Fields.LastShares aLastShares,
         QuickFix.Fields.LastPx aLastPx,
         QuickFix.Fields.LeavesQty aLeavesQty,
         QuickFix.Fields.CumQty aCumQty,
         QuickFix.Fields.AvgPx aAvgPx
     )
     : this()
 {
     this.OrderID = aOrderID;
     this.ExecID = aExecID;
     this.ExecTransType = aExecTransType;
     this.ExecType = aExecType;
     this.OrdStatus = aOrdStatus;
     this.Symbol = aSymbol;
     this.Side = aSide;
     this.OrderQty = aOrderQty;
     this.LastShares = aLastShares;
     this.LastPx = aLastPx;
     this.LeavesQty = aLeavesQty;
     this.CumQty = aCumQty;
     this.AvgPx = aAvgPx;
 }
Example #32
0
            public int Compare(object x, object y)
            {
                QuickFix a = x as QuickFix;
                QuickFix b = y as QuickFix;

                if (a == null || b == null)
                {
                    return(0);
                }

                return(a.SubText.CompareTo(b.SubText));
            }
Example #33
0
        public override void GoToQuickFix(QuickFix quickFix, int count, bool hasBang)
        {
            // This implementation could be much more riguorous but for next a simple navigation
            // of the next and previous error will suffice
            var command = quickFix.IsNext
                ? "View.NextError"
                : "View.PreviousError";

            for (var i = 0; i < count; i++)
            {
                SafeExecuteCommand(command);
            }
        }
Example #34
0
 public static Range ToRange(this QuickFix location)
 {
     return(new Range()
     {
         Start = new Position()
         {
             Character = location.Column,
             Line = location.Line
         },
         End = new Position()
         {
             Character = location.EndColumn,
             Line = location.EndLine
         },
     });
 }
Example #35
0
 public static Extensions.LanguageServer.Protocol.Models.Range ToRange(this QuickFix location)
 {
     return(new Extensions.LanguageServer.Protocol.Models.Range()
     {
         Start = new Position()
         {
             Character = location.Column,
             Line = location.Line
         },
         End = new Position()
         {
             Character = location.EndColumn,
             Line = location.EndLine
         },
     });
 }
Example #36
0
        public IEnumerable <QuickFix> GetCurrentFileMembersAsFlatWithoutAccessModifiers(CurrentFileMembersRequest request)
        {
            var context = new BufferContext(request, this._parser);

            var result = new List <QuickFix>();


            foreach (var item in context.ParsedContent.UnresolvedFile.TopLevelTypeDefinitions)
            {
                result.Add(new QuickFix()
                {
                    FileName    = item.Region.FileName
                    , Line      = item.Region.BeginLine
                    , Column    = item.Region.BeginColumn
                    , EndLine   = item.Region.EndLine
                    , EndColumn = item.Region.EndColumn
                    , Text      = item.Name
                });
            }

            var members = context.ParsedContent.UnresolvedFile.TopLevelTypeDefinitions
                          .SelectMany(x => x.Members);



            foreach (var item in members)
            {
                var ambience = new CSharpAmbience();
                ambience.ConversionFlags = ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
                var memberTitle = ambience.ConvertSymbol(item.Resolve(context.ResolveContext));

                var qf = new QuickFix()
                {
                    FileName    = item.Region.FileName
                    , Line      = item.Region.BeginLine
                    , Column    = item.Region.BeginColumn
                    , EndLine   = item.Region.EndLine
                    , EndColumn = item.Region.EndColumn
                    , Text      = memberTitle
                };

                result.Add(qf);
            }

            return(result.OrderBy(x => x.Text));
        }
Example #37
0
        GetFileRegions(Request request)
        {
            var context = new BufferContext(request, this._parser);

            var declarationCollector = new GetDirectivesAstVisitor();

            context.ParsedContent.SyntaxTree
            .AcceptVisitor(declarationCollector);

            var regions = declarationCollector.Directives
                          .Where(d => d.Type == PreProcessorDirectiveType.Region ||
                                 d.Type == PreProcessorDirectiveType.Endregion)
                          .Select(d => QuickFix.ForFirstLineInRegion
                                      (d.GetRegion(), context.Document));

            return(new QuickFixResponse(regions));
        }
        private static async Task <QuickFix> TranslateAsync(this QuickFix quickFix, OmniSharpWorkspace workspace, Request request)
        {
            var sameFile = string.IsNullOrEmpty(quickFix.FileName);
            var fileName = !sameFile ? quickFix.FileName : request.FileName;

            if (string.IsNullOrEmpty(fileName))
            {
                return(quickFix);
            }

            var(line, newFileName) = await LineIndexHelper.TranslateFromGenerated(fileName, quickFix.Line, workspace, sameFile);

            quickFix.Line     = line;
            quickFix.FileName = newFileName;

            (line, _) = await LineIndexHelper.TranslateFromGenerated(fileName, quickFix.EndLine, workspace, sameFile);

            quickFix.EndLine = line;

            return(quickFix);
        }
Example #39
0
//			Hashtable ht=new Hashtable();
//
//			foreach ( QuickFix qf in fixes )
//			{
//				string main=qf.MainText;
//				TreeNode tnMain=ht[main] as TreeNode;
//				if ( tnMain == null )
//				{
//					tnMain=new TreeNode(main);
//					tnMain.ImageIndex=1;
//					tnMain.SelectedImageIndex=1;
//					elementList.Nodes.Add(tnMain);
//					ht[main]=tnMain;
//				}
//
//				string sub=qf.SubText;
//
//				if ( sub != null )
//				{
//					if ( tnMain.Tag == null && tnMain.Nodes.Count == 0 )
//					{
//						tnMain.Text+=" "+sub;
//						tnMain.Tag=qf;
//					}
//					else
//					{
//						if ( tnMain.Tag != null )
//						{
//							QuickFix qfPrev=tnMain.Tag as QuickFix;
//
//							TreeNode tnPrev=new TreeNode(qfPrev.SubText);
//							tnPrev.Tag=qfPrev;
//							tnPrev.ImageIndex=2;
//							tnPrev.SelectedImageIndex=2;
//
//							tnMain.Text=main;
//							tnMain.Tag=null;
//							tnMain.Nodes.Add(tnPrev);
//						}
//						TreeNode tnSub=new TreeNode(sub);
//						tnMain.Nodes.Add(tnSub);
//						tnMain.Expand();
//						tnSub.Tag=qf;
//						tnSub.ImageIndex=2;
//						tnSub.SelectedImageIndex=2;
//					}
//				}
//				else
//				{
//					tnMain.Tag=qf;
//				}
//			}

        private void QuickFixSelected(object sender, EventArgs e)
        {
            TreeNode node = elementList.SelectedNode;

            if (node == null)
            {
                return;
            }

            QuickFix qf = node.Tag as QuickFix;

            if (qf == null)
            {
                return;
            }

            editor.PerformQuickFix(qf);
            // TODO: L: see if this is called twice
            UpdateLocation();
            ProcessUpdate();
            UpdateChoices();
            editor.Focus();
        }
Example #40
0
        public QuickFix Parse(string line)
        {
            if (!line.Contains("warning CS") && !line.Contains("error CS"))
            {
                return(null);
            }

            var match = GetMatches(line, @".*(Source file '(.*)'.*)");

            if (match.Matched)
            {
                var matches  = match.Matches;
                var quickFix = new QuickFix
                {
                    FileName = matches[0].Groups[2].Value,
                    Text     = matches[0].Groups[1].Value.Replace("'", "''")
                };

                return(quickFix);
            }

            match = GetMatches(line, @"\s*(.*cs)\((\d+),(\d+)\).*(warning|error) CS\d+: (.*) \[");
            if (match.Matched)
            {
                var matches  = match.Matches;
                var quickFix = new QuickFix
                {
                    FileName = matches[0].Groups[1].Value,
                    Line     = int.Parse(matches[0].Groups[2].Value),
                    Column   = int.Parse(matches[0].Groups[3].Value),
                    Text     = "[" + matches[0].Groups[4].Value + "] " + matches[0].Groups[5].Value.Replace("'", "''")
                };

                return(quickFix);
            }
            return(null);
        }
Example #41
0
        private void Sort(ICollection fixes, int maxItems)
        {
            topGroups.Clear();

            foreach (QuickFix qf in fixes)
            {
                QuickFixGroup qfg = (QuickFixGroup)topGroups[qf.MainText];
                if (qfg == null)
                {
                    qfg                 = new QuickFixGroup();
                    qfg.Name            = qf.MainText;
                    topGroups[qfg.Name] = qfg;
                }
                qfg.Items.Add(qf);
            }

            TopItems.Clear();

            foreach (QuickFixGroup qfg in topGroups.Values)
            {
                if (qfg.Items.Count == 1)
                {
                    TopItems.Add(qfg.Items[0]);
                    continue;
                }

                if (qfg.Items.Count > maxItems)
                {
                    qfg.Items.Sort(new Sorter());
                    QuickFixGroup newGroup  = null;
                    ArrayList     origItems = qfg.Items;
                    qfg.Items = new ArrayList();

                    int count = 0;
                    foreach (QuickFix qf in origItems)
                    {
                        if (newGroup == null)
                        {
                            newGroup      = new QuickFixGroup();
                            newGroup.Name = qf.SubText;
                            count         = 0;
                        }
                        newGroup.Items.Add(qf);
                        count++;
                        if (count > maxItems)
                        {
                            newGroup.Name += " - " + qf.SubText;
                            qfg.Items.Add(newGroup);
                            newGroup = null;
                        }
                    }
                    if (newGroup != null)
                    {
                        QuickFix qf = (QuickFix)origItems[origItems.Count - 1];
                        newGroup.Name += " - " + qf.SubText;
                        qfg.Items.Add(newGroup);
                    }
                }
                TopItems.Add(qfg);
            }
        }
Example #42
0
 void IVimHost.GoToQuickFix(QuickFix quickFix, int count, bool hasBang)
 {
     GoToQuickFix(quickFix, count, hasBang);
 }
Example #43
-4
 public OrderStatusRequest(
   QuickFix.ClOrdID aClOrdID,
   QuickFix.Side aSide )
 : base(MsgType()) {
   set(aClOrdID);
   set(aSide);
 }