// <summary>
 // Is the given op one of the ConstantBaseOp-s
 // </summary>
 internal static bool IsConstantBaseOp(OpType opType)
 {
     return opType == OpType.Constant ||
            opType == OpType.InternalConstant ||
            opType == OpType.Null ||
            opType == OpType.NullSentinel;
 }

 public Operation(OpType type, int row, int column, QuadValue direction = QuadValue.Left | QuadValue.Right | QuadValue.Up | QuadValue.Down)
 {
     _type = type;
     _row = row;
     _column = column;
     _direction = direction;
 }

 protected static void Assert(bool condition, string format, OpType op, object arg1, object arg2)
 {
     if (!condition)
     {
         Debug.Assert(false, String.Format(CultureInfo.InvariantCulture, format, Dump.AutoString.ToString(op), arg1, arg2));
     }
 }

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate (bundle);

            rssUtil.bgndWorker.RunWorkerCompleted += (sender, e) =>
            {

                //todo clear list
                listViewRSS.Adapter = new ArrayAdapter<string> (this, Android.Resource.Layout.SimpleListItem1,
                                                                rssUtil.RssFeeds.Select(x=>x.Title).ToArray());

                SetProgressBarIndeterminateVisibility (false);
                opType = OpType.Feeds;
            };

            RequestWindowFeature (WindowFeatures.ActionBar);
            RequestWindowFeature (WindowFeatures.Progress);
            RequestWindowFeature (WindowFeatures.IndeterminateProgress);

            SetProgressBarIndeterminate (true);
            SetProgressBarIndeterminateVisibility (true);

            ActionBar.NavigationMode = ActionBarNavigationMode.Tabs;
            ActionBar.Title = "Eyegregator";
            ActionBar.SetDisplayShowTitleEnabled (true);

            CreateDB ();

            SetContentView (Resource.Layout.Main);
            listViewRSS = (ListView)FindViewById (Resource.Id.listView);
            listViewRSS.Clickable = true;
        }

		// should form a binary tree, can't have more than 2 children
		public MathNode(UberNode parent, string scriptInput, OpType opType)
			: base(parent, scriptInput)
		{
			Children.Add(null);
			Children.Add(null);
			OpTypeVal = opType;
		}

 internal SetOp(OpType opType, VarVec outputs, VarMap left, VarMap right)
     : this(opType)
 {
     m_varMap = new VarMap[2];
     m_varMap[0] = left;
     m_varMap[1] = right;
     m_outputVars = outputs;
 }

        /// <summary>
        /// Basic constructor
        /// </summary>
        /// <param name="opType">The OpType we're interested in processing</param>
        /// <param name="nodeProcessDelegate">The callback to invoke</param>
        protected Rule(OpType opType, ProcessNodeDelegate nodeProcessDelegate)
        {
            Debug.Assert(nodeProcessDelegate != null, "null process delegate");
            Debug.Assert(opType != OpType.NotValid, "bad OpType");
            Debug.Assert(opType != OpType.Leaf, "bad OpType - Leaf");

            m_opType = opType;
            m_nodeDelegate = nodeProcessDelegate;
        }

        private readonly List<RelProperty> m_relProperties; // list of relationship properties for which we have values

        #endregion

        #region constructors

        internal NewEntityBaseOp(OpType opType, TypeUsage type, bool scoped, EntitySet entitySet, List<RelProperty> relProperties)
            : base(opType, type)
        {
            Debug.Assert(scoped || entitySet == null, "entitySet cann't be set of constructor isn't scoped");
            DebugCheck.NotNull(relProperties);
            m_scoped = scoped;
            m_entitySet = entitySet;
            m_relProperties = relProperties;
        }

 internal NestBaseOp(
     OpType opType, List<SortKey> prefixSortKeys,
     VarVec outputVars,
     List<CollectionInfo> collectionInfoList)
     : base(opType)
 {
     m_outputs = outputVars;
     m_collectionInfoList = collectionInfoList;
     m_prefixSortKeys = prefixSortKeys;
 }

        public ScreenEdit(t_Screen t_Scr, OpType moptype)
        {
            InitializeComponent();

            Scree = t_Scr;
            if (moptype == OpType.Alert)
            {
                txtName.Text = t_Scr.ScreenName;
                txtImage.Text = t_Scr.ImageURL;
            }
            optype = moptype;
            BindSite();
        }

        public TP_ButtonSetPropertyEdit(TP_ButtonSetProperty _BaseWindow,OpType mopType)
        {
            InitializeComponent();
            _OpType = mopType;

            _ContentX = _BaseWindow;

            InitProperty();
            if (mopType == OpType.Alert)
            {
                OpItem = (ScreenAddShowName)_ContentX.gvList.SelectedItem;
                txtShowName.Text = OpItem.ScreenShowName;
                cbScreenList.SelectedItem = OpItem.Screen;
            }
        }

        public List<Polygon> Clip(Polygon p1, Polygon p2, OpType operation)
        {
            List<IntPoint> pol1 = new List<IntPoint>();
            List<IntPoint> pol2 = new List<IntPoint>();
            List<List<IntPoint>> res = new List<List<IntPoint>>();

            foreach (Point point in p1.Points) {
                pol1.Add(new IntPoint(point.X, point.Y));
            }
            foreach (Point point in p2.Points) {
                pol2.Add(new IntPoint(point.X, point.Y));
            }

            Clipper clipper = new Clipper();
            clipper.AddPolygon(pol1, PolyType.ptSubject);
            clipper.AddPolygon(pol2, PolyType.ptClip);

            switch (operation) {
                case OpType.Difference:
                    clipper.Execute(ClipType.ctDifference, res);
                    break;
                case OpType.Intersection:
                    clipper.Execute(ClipType.ctIntersection, res);
                    break;
                case OpType.Union:
                    clipper.Execute(ClipType.ctUnion, res);
                    break;
                case OpType.Xor:
                    clipper.Execute(ClipType.ctXor, res);
                    break;
            }
            List<Polygon> ret = new List<Polygon>();

            foreach (var poly in res) {
                Polygon pol = new Polygon() { Points = new List<Point>() };

                foreach (var poi in poly) {
                    pol.Points.Add(new Point() { X = poi.X, Y = poi.Y });
                }

                ret.Add(pol);
            }
            return ret;
        }

 //ScreenEdit _mw)
 public ScreenViewModel(t_Screen _mScreen, OpType mType, ScreenEdit mWindow)
 {
     OperationType = mType;
     if (mType == OpType.Add)
     {
         _ParentScreen = _mScreen;
         ScreenObj = new t_Screen();
         _ScreenObj = new t_Screen();
     }
     else
     {
         ScreenObj = new t_Screen();
         ScreenObj.Clone(_mScreen);
         _ScreenObj = _mScreen;
     }
     _Window = mWindow;
     //UpdatetxtSource(_Window.gridContent);
     Init();
 }

 public bool leftasso = true; //is the operator left associative? most are, so save some lines w/ default value
 public OpToken(OpType type)
 {
     this.type = type;
     switch (type)
     {
         case OpType.ADD:
             precedence = 0;                    
             break;
         case OpType.SUB:
             precedence = 0;                    
             break;
         case OpType.MUL:
             precedence = 1;                    
             break;
         case OpType.DIV:
             precedence = 1;                    
             break;
         case OpType.MOD:
             precedence = 1;                    
             break;
         case OpType.LP:
             precedence = -999999; //these will be handled specially
             break;
         case OpType.RP:
             precedence = -999999; //these will be handled specially
             break;
         case OpType.EXP:
             precedence = 2;
             leftasso = false;
             break;
         case OpType.LSHIFT:
             precedence = -1;
             length = 2;
             break;
         case OpType.RSHIFT:
             precedence = -1;
             length = 2;
             break;
     }
 }

 protected static void AssertOpType(Op op, OpType opType)
 {
     Assert(op.OpType == opType, "OpType Mismatch: Expected {0}; found {1}", op.OpType, Dump.AutoString.ToString(opType));
 }

 // Pattern constructor
 internal SortBaseOp(OpType opType)
     : base(opType)
 {
     Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
 }

 private static bool CheckEntry(OpType opType, PlanCompilerPhase phase)
 {
     var hash = ComputeHash(opType, phase);
     return s_ValidOpTypes.IsSet(hash);
 }

 private static void AddAllEntry(BitVec opVector, OpType opType)
 {
     foreach (var phase in _planCompilerPhases)
     {
         AddSingleEntry(opVector, opType, phase);
     }
 }

 private static void AddEntry(BitVec opVector, OpType opType, params PlanCompilerPhase[] phases)
 {
     foreach (var phase in phases)
     {
         AddSingleEntry(opVector, opType, phase);
     }
 }

 public void ReadOut(BinaryReader reader)
 {
     _type = (OpType)reader.ReadInt32();
 }