Pastebin: 最後のスクリーニング結果 SystemTrading.cs

Formato

Plain text

Post date

2015-04-04 22:29

Publication Period

Unlimited

 /*
  * Copyright (c) Daisuke OKAJIMA    All rights reserved.
  * 
  * $Id$
  */
 using System;
 using System.Threading;
 using System.Collections;
 using System.Diagnostics;
 
 using Travis.Util;
 
 using Zanetti.Data;
 using Zanetti.Config;
 
 //スクリーニングとセオリー検証の共通機能をまとめる
 namespace Zanetti.SystemTrading
 {
         //銘柄列挙関係
 
         [EnumDesc(typeof(FilterType))]
         internal enum FilterType {
                 [EnumValue(Description="すべての銘柄")] None,
                 [EnumValue(Description="日経平均採用銘柄")] Nikkei225,
                 [EnumValue(Description="平均売買代金上位500銘柄")] Active500,
                 [EnumValue(Description="東証・大証１部")] Div1,
                 [EnumValue(Description="東証・大証１部以外")] NotDiv1,
                 [EnumValue(Description="お気に入りのフォルダ")] Favorite,
         [EnumValue(Description = "最後のスクリーニング結果")] LastResult
         }
 
         [EnumDesc(typeof(TradingType))]
         internal enum TradingType {
                 [EnumValue(Description="買い")] Long,
                 [EnumValue(Description="売り")] Short
         }
 
         [EnumDesc(typeof(EntryType))]
         internal enum EntryType {
                 [EnumValue(Description="当日終値")] TodayClose,
                 [EnumValue(Description="翌日始値")] TomorrowOpen,
                 [EnumValue(Description="逆指値")] Gyakusashine
         }
 
 
         internal abstract class BrandEnumerator {
                 
                 //プログレスバーのコントロールがあるので、Countで返した値だけNextを呼び、実際に処理対象にするのはCheckに通ったやつのみというルールでいく
                 public abstract AbstractBrand Next();
                 
                 public abstract bool Check(AbstractBrand br);
 
                 public abstract int Count {
                         get;
                 }
                 public abstract string Description {
                         get;
                 }
         }
 
         internal class AllBrandEnumerator : BrandEnumerator {
                 private IDictionaryEnumerator _e;
                 public AllBrandEnumerator() {
                         _e = Env.BrandCollection.GetEnumerator();
                 }
                 public override AbstractBrand Next() {
                         return _e.MoveNext()? (AbstractBrand)_e.Value : null;
                 }
                 public override int Count {
                         get {
                                 return Env.BrandCollection.TotalCount;
                         }
                 }
                 public override bool Check(AbstractBrand br) {
                         return br is BasicBrand && !br.IsBuiltIn;
                 }
                 public override string Description {
                         get {
                                 return "全銘柄";
                         }
                 }
 
         }
 
     internal class BookmarkedBrandEnumerator2 : BrandEnumerator
     {
         private ArrayList _brands;
         private int _index;
         public BookmarkedBrandEnumerator2()
         {
             _brands = new ArrayList();
             _index = 0;
         }
         public override AbstractBrand Next()
         {
             AbstractBrand r = null;
             try
             {
                 if (Env.LastScreeningResult.ResultCount <= _index) return null;
                 object t = Env.LastScreeningResult.GetAt(_index++);
                 Screening.ScreeningResultEntry ent = t as Screening.ScreeningResultEntry;
                 r = ent.Brand;
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
             }
             return r;
         }
         public override int Count
         {
             get
             {
                 return Env.LastScreeningResult.ResultCount;
             }
         }
         public override bool Check(AbstractBrand br)
         {
             return true;
         }
         public override string Description
         {
             get
             {
                 return "ブックマーク ";
             }
         }
 
 
 
     }
 
         internal class FilteredBrandEnumerator : AllBrandEnumerator {
                 private FilterType _filter;
                 public FilteredBrandEnumerator(FilterType t) {
                         _filter = t;
                 }
                 public FilterType FilterType {
                         get {
                                 return _filter;
                         }
                 }
                 public override bool Check(AbstractBrand br0) {
                         if(!base.Check(br0)) return false;
                         BasicBrand br = br0 as BasicBrand;
 
                         switch(_filter) {
                                 case FilterType.Div1:
                                         return br.Market==MarketType.T1 || br.Market==MarketType.O1;
                                 case FilterType.NotDiv1:
                                         return br.Market!=MarketType.T1 && br.Market!=MarketType.O1;
                                 case FilterType.Nikkei225:
                                         return br.Nikkei225;
                                 case FilterType.Active500:
                                         return br.Active500;
                                 default:
                                         return br.Market!=MarketType.B; //指数は当然含めない
                         }
                 }
                 public override string Description {
                         get {
                                 return EnumDescAttribute.For(typeof(FilterType)).GetDescription(_filter);
                         }
                 }
 
         }
 
         internal class SingleBrandEnumerator : BrandEnumerator {
                 private AbstractBrand _br;
                 private bool _finished;
                 public SingleBrandEnumerator(AbstractBrand br) {
                         _br = br;
                 }
                 public override AbstractBrand Next() {
                         if(_finished)
                                 return null;
                         else {
                                 _finished = true;
                                 return _br;
                         }
                 }
                 public override int Count {
                         get {
                                 return 1;
                         }
                 }
                 public override bool Check(AbstractBrand br) {
                         return true;
                 }
                 public override string Description {
                         get {
                                 return _br.Name;
                         }
                 }
 
         }
 
         internal class BookmarkedBrandEnumerator : BrandEnumerator {
                 private BookmarkFolder _bookmarkFolder;
                 private ArrayList _brands;
                 private int _index;
                 public BookmarkedBrandEnumerator(BookmarkFolder f) {
                         _bookmarkFolder = f;
                         _brands = new ArrayList();
                         _bookmarkFolder.GatherTo(_brands, GatherOption.Brand);
                         _index = 0;
                 }
                 public override AbstractBrand Next() {
                         AbstractBrand r = null;
                         while(r==null && _index<_brands.Count) {
                                 object t = _brands[_index++];
                                 r = t as AbstractBrand;
                         } 
                         return r;
                 }
                 public override int Count {
                         get {
                                 return _brands.Count;
                         }
                 }
                 public override bool Check(AbstractBrand br) {
                         return true;
                 }
                 public override string Description {
                         get {
                                 return "ブックマーク " + _bookmarkFolder.Name;
                         }
                 }
 
 
 
         }
 
         //横断して何かをする基底クラス
         internal abstract class SystemTradingExecutor {
                 protected string _errorMessage;
                 protected string _name;
                 protected BrandEnumerator _brandEnumerator;
                 protected IntPtr _notifyTarget;
                 protected Thread _thread;
 
                 protected SystemTradingExecutor(string name) {
                         _name = name;
                 }
                 public BrandEnumerator BrandEnumerator {
                         get {
                                 return _brandEnumerator;
                         }
                         set {
                                 _brandEnumerator = value;
                         }
                 }
 
                 public string Name {
                         get {
                                 return _name;
                         }
                 }
                 public string ErrorMessage {
                         get {
                                 return _errorMessage;
                         }
                 }
                 public abstract SystemTradingResult Result {
                         get;
                 }
 
                 public void Execute() {
                         //初期化
                         BeforeExecute();
                         this.Result.BrandDescription = _brandEnumerator.Description;
 
                         AbstractBrand br = _brandEnumerator.Next();
                         while(br!=null) {
                                 try {
                                         if(_brandEnumerator.Check(br)) {
                                                 ExecuteBrandResult t = ExecuteBrand(br);
                                                 this.Result.CheckedBrandCount++; //!!これはここでインクリメントするが、エラーの情報は派生クラス側というのがわかりづらい仕様だ
                                                 if(t==ExecuteBrandResult.TooManyResult) return;
                                         }
                                         if(_notifyTarget!=IntPtr.Zero)
                                                 Win32.SendMessage(_notifyTarget, AsyncConst.WM_ASYNCPROCESS, new IntPtr(br.Code), new IntPtr(AsyncConst.LPARAM_PROGRESS_SUCCESSFUL));
 
                                         br = _brandEnumerator.Next();
                                 }
                                 catch(TradeDataOverflowException ) {
                                         Debug.WriteLine("Overflow in screening " + br.Code);
                                         this.Result.AddDataErrorBrand(br);
                                 }
                                 catch(Exception ex) {
                                         Debug.WriteLine(ex.StackTrace);
                                         _errorMessage = ex.Message;
                                         if(_notifyTarget!=IntPtr.Zero)
                                                 Win32.SendMessage(_notifyTarget, AsyncConst.WM_ASYNCPROCESS, IntPtr.Zero, new IntPtr(AsyncConst.LPARAM_ERROR));
                                 }
                         }
 
                         AfterExecute();
                 }
 
                 //実行のサポート
                 protected virtual void BeforeExecute() { }
                 protected virtual void AfterExecute() { }
                 protected abstract ExecuteBrandResult ExecuteBrand(AbstractBrand br);
 
                 //非同期実行
                 public void AsyncExecute(IntPtr target) {
                         _notifyTarget = target;
                         _thread = new Thread(new ThreadStart(Run));
                         _thread.Start();
                 }
                 private void Run() {
                         try {
                                 Execute();
                                 if(_notifyTarget!=IntPtr.Zero) Win32.SendMessage(_notifyTarget, AsyncConst.WM_ASYNCPROCESS, IntPtr.Zero, new IntPtr(AsyncConst.LPARAM_FINISHED));
                         }
                         catch(Exception ex) {
                                 _errorMessage = ex.Message;
                                 Util.SilentReportCriticalError(ex);
                                 if(_notifyTarget!=IntPtr.Zero) Win32.SendMessage(_notifyTarget, AsyncConst.WM_ASYNCPROCESS, IntPtr.Zero, new IntPtr(AsyncConst.LPARAM_ERROR));
                         }
                 }
 
                 public void Abort() {
                         if(_thread!=null)
                                 _thread.Abort();
                 }
         }
 
         internal enum ExecuteBrandResult {
                 Succeeded,
                 Ignored,
                 DataError,
                 Filtered,
                 TooManyResult
         }
 
         internal abstract class SystemTradingResult {
                 protected ArrayList _data;
                 protected string _brandDescription;
                 protected bool _sortRequired;
                 protected int _checkedCount;
                 protected ArrayList _dataErrorBrands;
                 protected bool _tooManyResults;
                 
                 public SystemTradingResult(int capacity) {
                         _data = new ArrayList(capacity);
                         _dataErrorBrands = new ArrayList();
                 }
 
                 public void AddDataErrorBrand(AbstractBrand br) {
                         _dataErrorBrands.Add(br);
                 }
 
                 public SystemTradingResultEntry GetAt(int index) {
                         if(_sortRequired) {
                                 _data.Sort();
                                 _sortRequired = false;
                         }
                         return (SystemTradingResultEntry)_data[index];
                 }
                 public string BrandDescription {
                         get {
                                 return _brandDescription;
                         }
                         set {
                                 _brandDescription = value;
                         }
                 }
 
                 public int CheckedBrandCount {
                         get {
                                 return _checkedCount;
                         }
                         set {
                                 _checkedCount = value;
                         }
                 }
                 public bool HasTooManuResults {
                         get {
                                 return _tooManyResults;
                         }
                         set {
                                 _tooManyResults = value;
                         }
                 }
 
                 public IList DataErrorBrands {
                         get {
                                 return _dataErrorBrands;
                         }
                 }
                 
                 public int ResultCount {
                         get {
                                 return _data.Count;
                         }
                 }
         }
 
         internal abstract class SystemTradingResultEntry : IComparable {
                 protected AbstractBrand _brand;
 
                 public SystemTradingResultEntry(AbstractBrand br) {
                         _brand = br;
                 }
 
                 public AbstractBrand Brand {
                         get {
                                 return _brand;
                         }
                 }
 
                 public abstract int CompareTo(object obj);
         }
 
 }