public override void SetContentOffset(CGPoint contentOffset, bool animated) { base.SetContentOffset(contentOffset, animated); currentIndex = (int)Math.Round(ContentOffset.X / Constants.DeviceWidth); currentItem = stackItems [currentIndex]; Console.WriteLine("CURRENT INDEX " + currentIndex); }
void CheckItem(IExecutionEngine engine, IStackItem item) { int c = engine.ResultStack.Count; engine.ResultStack.Push(item); Assert.AreEqual(engine.ResultStack.Count, c + 1); Assert.IsTrue(engine.ResultStack.TryPeek(0, out IStackItem obj)); // PEEK obj.Dispose(); obj = engine.ResultStack.Peek(0); Assert.IsNotNull(obj); Assert.AreEqual(obj.Type, item.Type); Assert.IsTrue(obj.Equals(item)); // POP obj.Dispose(); obj = engine.ResultStack.Pop(); Assert.AreEqual(engine.ResultStack.Count, c); Assert.IsNotNull(obj); Assert.AreEqual(obj.Type, item.Type); Assert.IsTrue(obj.Equals(item)); obj.Dispose(); }
bool updateCurrentElement() { int item = (int)Math.Round(ContentOffset.X / Constants.DeviceWidth); if (item >= NumberOfItems || item < 0) { itemChanged = false; return(itemChanged); } if (item != currentIndex) { prevIndex = currentIndex; currentIndex = item; stackItems [prevIndex].moveToOriginalFrameAnimated(false); currentItem = stackItems [currentIndex]; currentItem.moveToFullScreenWindowAnimated(false); itemChanged = true; } else { itemChanged = false; } return(itemChanged); }
private IStackItem DeserializeStackItem(IExecutionEngine engine, BinaryReader reader) { EStackItemType type = (EStackItemType)reader.ReadByte(); switch (type) { case EStackItemType.ByteArray: return(engine.CreateByteArray(reader.ReadVarBytes())); case EStackItemType.Bool: return(engine.CreateBool(reader.ReadBoolean())); case EStackItemType.Integer: return(engine.CreateInteger(new BigInteger(reader.ReadVarBytes()))); case EStackItemType.Array: case EStackItemType.Struct: { IArrayStackItem array; if (type == EStackItemType.Struct) { array = engine.CreateStruct(); } else { array = engine.CreateArray(); } ulong count = reader.ReadVarInt(); while (count-- > 0) { array.Add(DeserializeStackItem(engine, reader)); } return(array); } case EStackItemType.Map: { IMapStackItem map = engine.CreateMap(); ulong count = reader.ReadVarInt(); while (count-- > 0) { IStackItem key = DeserializeStackItem(engine, reader); IStackItem value = DeserializeStackItem(engine, reader); map[key] = value; key.Dispose(); value.Dispose(); } return(map); } default: throw new FormatException(); } }
public void WriteHtmlFile(IStackItem item) { //transform to html XslCompiledTransform transformer = new XslCompiledTransform(); using (StringReader stringReader = new StringReader(_xsltString)) { XmlReaderSettings settings = new XmlReaderSettings(); settings.DtdProcessing = DtdProcessing.Parse; using (XmlReader xmlReader = XmlReader.Create(stringReader, settings)) { transformer.Load(xmlReader); } settings = null; } string htmlString; using (StringReader stringReader = new StringReader(item.FileContent)) { using (XmlReader xmlReader = XmlReader.Create(stringReader)) { using (StringWriter writer = new StringWriter()) { transformer.Transform(xmlReader, null, writer); htmlString = writer.ToString(); } } } //write to file string pathToHtmlFile = Path.Combine(_htmlDirectoryInfo.FullName, item.FileNameNoExtension + ".html"); File.AppendAllText(pathToHtmlFile, htmlString); }
public override void Set(IStackItem key, IStackItem value) => NeoVM.MapStackItem_Set ( _handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle, value == null ? IntPtr.Zero : ((INativeStackItem)value).Handle );
/// <summary> /// Add a stackItem to the stack. /// </summary> /// <param name="stackObject"></param> public void Add(IStackItem stackItem) { if (!finishingExecution) { LIFOStack.Push(stackItem); stackItemCollection.Add(stackItem); manualResetEvent.Set(); } }
public override IEnumerator <KeyValuePair <IStackItem, IStackItem> > GetEnumerator() { for (int x = 0, c = Count; x < c; x++) { IStackItem key = Engine.ConvertFromNative(NeoVM.MapStackItem_GetKey(_handle, x)); IStackItem value = Engine.ConvertFromNative(NeoVM.MapStackItem_GetValue(_handle, x)); yield return(new KeyValuePair <IStackItem, IStackItem>(key, value)); } }
private void ProcessIStackItem(IStackItem item, bool silenceEvents = false) { if (!item.IsProcessed) { item.Process(); item.IsProcessed = true; if (!silenceEvents) { ItemProcessed?.BeginInvoke(this, item, null, null); } } }
public override bool TryGetValue(IStackItem key, out IStackItem value) { var ret = NeoVM.MapStackItem_Get(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle); if (ret == IntPtr.Zero) { value = null; return(false); } value = Engine.ConvertFromNative(ret); return(true); }
/// <summary> /// Try to obtain the element at `index` position, without consume them /// -1=Last , -2=Last-1 , -3=Last-2 /// </summary> /// <param name="index">Index</param> /// <param name="obj">Object</param> /// <returns>Return tru eif object exists</returns> public override bool TryPeek(int index, out IStackItem obj) { var ptr = NeoVM.StackItems_Peek(_handle, index); if (ptr == IntPtr.Zero) { obj = null; return(false); } obj = Engine.ConvertFromNative(ptr); return(true); }
public void Process() { XmlFileReader xfr = new XmlFileReader(_producerConsumer.GetConfigurationReader().GetXmlFilesDirectory(), _producerConsumer.GetConfigurationReader().GetXmlFilesProcessedDirectory(), _producerConsumer.FileSystemHelper);; int numberOfFiles = _producerConsumer.GetConfigurationReader().GetXmlFilesDirectory().GetFiles().Length; while (xfr.GetNextStackItem() != null) { IStackItem si = xfr.GetNextStackItem(); _producerConsumer.Queue.Enqueue(si); //_producerConsumer.lollypop.Set(); _producerConsumer.IsDoneReading = false; } _producerConsumer.IsDoneReading = true; }
public XmlFileReaderTest() { _reader = new ConfigurationReader(); IFileSystemHelper fsh = (IFileSystemHelper)(new Mock <FileSystemHelper>().Object); _xfr = new XmlFileReader(_reader.GetXmlFilesDirectory(), _reader.GetXmlFilesProcessedDirectory(), fsh); _numberOfFiles = _reader.GetXmlFilesDirectory().GetFiles().Length; _stackItems = new List <IStackItem>(); while (_xfr.GetNextStackItem() != null) { IStackItem si = _xfr.GetNextStackItem(); _stackItems.Add(si); } }
public void Process() { Thread.Sleep(100); do { //_producerConsumer.lollypop.WaitOne(); HtmlFileWriter hfw = new HtmlFileWriter(_producerConsumer.GetConfigurationReader().GetHtmlFilesDirectory(), _producerConsumer.GetConfigurationReader().GetResourcesDirectory(), _producerConsumer.FileSystemHelper); IStackItem item = null; while (_producerConsumer.Queue.TryDequeue(out item)) { hfw.WriteHtmlFile(item); // do stuff } _producerConsumer.IsDoneWriting = true; } while (!_producerConsumer.IsDoneReading || !_producerConsumer.Queue.IsEmpty); }
private bool Runtime_Deserialize(IExecutionEngine engine) { using (var context = engine.CurrentContext) { if (context == null) { return(false); } if (!context.EvaluationStack.TryPop(out IStackItem it)) { return(false); } var data = it.ToByteArray(); it.Dispose(); using (MemoryStream ms = new MemoryStream(data, false)) using (BinaryReader reader = new BinaryReader(ms)) { IStackItem item = null; try { item = DeserializeStackItem(engine, reader); } catch { if (item != null) { item.Dispose(); } return(false); } context.EvaluationStack.Push(item); if (item != null) { item.Dispose(); } } } return(true); }
private void CheckValue(IStackItem it, object ret) { if (ret is BigInteger bi) { Assert.IsTrue(it is IntegerStackItem); Assert.AreEqual(bi, ((IntegerStackItem)it).Value); } else if (ret is byte[] bf) { Assert.IsTrue(it is ByteArrayStackItem); CollectionAssert.AreEqual(bf, ((ByteArrayStackItem)it).Value); } else if (ret is bool bl) { Assert.IsTrue(it is BooleanStackItem); Assert.AreEqual(bl, ((BooleanStackItem)it).Value); } }
/// <summary> /// Try Pop object casting to this type /// </summary> /// <typeparam name="TStackItem">Object type</typeparam> /// <param name="item">Item</param> /// <returns>Return false if it is something wrong</returns> public override bool TryPop <TStackItem>(out TStackItem item) { IntPtr ptr = NeoVM.StackItems_Pop(_handle); if (ptr == IntPtr.Zero) { item = default(TStackItem); return(false); } IStackItem ret = Engine.ConvertFromNative(ptr); if (ret is TStackItem ts) { item = (TStackItem)ret; return(true); } item = default(TStackItem); return(false); }
public override int IndexOf(IStackItem item) => NeoVM.ArrayStackItem_IndexOf(Handle, ((INativeStackItem)item).Handle);
public override bool Remove(IStackItem key) { return(NeoVM.MapStackItem_Remove(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle) == NeoVM.TRUE); }
public override bool TryPeek(int index, out IStackItem obj) { throw new NotImplementedException(); }
private void SerializeStackItem(IStackItem item, BinaryWriter writer) { switch (item) { case ByteArrayStackItem _: { writer.Write((byte)EStackItemType.ByteArray); writer.WriteVarBytes(item.ToByteArray()); break; } case BooleanStackItem bl: { writer.Write((byte)EStackItemType.Bool); writer.Write(bl.Value); break; } case IntegerStackItem _: { writer.Write((byte)EStackItemType.Integer); writer.WriteVarBytes(item.ToByteArray()); break; } case InteropStackItem _: throw new NotSupportedException(); case ArrayStackItem array: { if (array.IsStruct) { writer.Write((byte)EStackItemType.Struct); } else { writer.Write((byte)EStackItemType.Array); } writer.WriteVarInt(array.Count); foreach (IStackItem subitem in array) { SerializeStackItem(subitem, writer); } break; } case MapStackItem map: { writer.Write((byte)EStackItemType.Map); writer.WriteVarInt(map.Count); foreach (var pair in map) { SerializeStackItem(pair.Key, writer); SerializeStackItem(pair.Value, writer); } break; } } }
public void TestFileWriter() { IStackItem itm = _xfr.GetNextStackItem(); _hfw.WriteHtmlFile(itm); }
/// <summary> /// Raise OnAltStackChange /// </summary> /// <param name="stack">Stack</param> /// <param name="item">Item</param> /// <param name="index">Index</param> /// <param name="operation">Operation</param> public virtual void RaiseOnAltStackChange(IStackItemsStack stack, IStackItem item, int index, ELogStackOperation operation) { OnAltStackChange?.Invoke(stack, item, index, operation); }
public override void Set(int index, IStackItem item) => NeoVM.ArrayStackItem_Set(Handle, ((INativeStackItem)item).Handle, index);
public override void Insert(int index, IStackItem item) { NeoVM.ArrayStackItem_Insert(Handle, ((INativeStackItem)item).Handle, index); }
public override bool ContainsKey(IStackItem key) { return(NeoVM.MapStackItem_Get(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle) != IntPtr.Zero); }
public override void Push(IStackItem item) { throw new NotImplementedException(); }
public void TestArrayStackItem() { using (var engine = CreateEngine(null)) { for (int x = 0; x < 2; x++) { bool isStruct = x == 1; // First test for array, second for Struct using (var ar = isStruct ? engine.CreateStruct() : engine.CreateArray()) { Assert.AreEqual(isStruct, ar.IsStruct); // Create two random integer types foreach (var bi in TestBigIntegers) { using (var btest = engine.CreateInteger(bi)) { // Check contains Assert.IsFalse(ar.Contains(btest)); // Check empty Assert.AreEqual(0, ar.Count); // Add and check count ar.Add(btest); Assert.AreEqual(1, ar.Count); // Check item by position using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, btest.Value); // Remove Assert.IsTrue(ar.Remove(btest)); } } // Clear ar.Clear(); Assert.AreEqual(0, ar.Count); // Add bool and check contains using (var bkill = engine.CreateBool(true)) { Assert.AreEqual(ar.IndexOf(bkill), -1); ar.Add(bkill); Assert.AreEqual(ar.IndexOf(ar), -1); Assert.IsTrue(ar.Contains(bkill)); } // Create new array IArrayStackItem ar2; { var art = new IStackItem[] { engine.CreateBool(true), engine.CreateBool(false) }; ar2 = engine.CreateArray(art); foreach (var it in art) { it.Dispose(); } } Assert.IsFalse(ar.Contains(ar2)); // Replace bool with array ar[0] = ar2; // Check IndexOf Assert.AreEqual(ar.IndexOf(ar2), 0); // Check count Assert.AreEqual(1, ar.Count); // Remove first element ar.RemoveAt(0); // Check count Assert.AreEqual(0, ar.Count); // Add 1,2,3 { var art = new IStackItem[] { engine.CreateInteger(1), engine.CreateInteger(2), engine.CreateInteger(3) }; ar.Add(art); foreach (var it in art) { it.Dispose(); } } // Remove 2 ar.RemoveAt(1); // Check count Assert.AreEqual(2, ar.Count); // Check values 1 and 3 using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, 1); using (var iau = (IntegerStackItem)ar[1]) Assert.AreEqual(iau.Value, 3); // Insert bool using (var inte = engine.CreateBool(true)) ar.Insert(1, inte); // Check values using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, 1); using (var iau = (BooleanStackItem)ar[1]) Assert.IsTrue(iau.Value); using (var iau = (IntegerStackItem)ar[2]) Assert.AreEqual(iau.Value, 3); } } } }
public override void Add(IStackItem item) => NeoVM.ArrayStackItem_Add(Handle, ((INativeStackItem)item).Handle);
/// <summary> /// Push objet to the stack /// </summary> /// <param name="item">Object</param> public override void Push(IStackItem item) { NeoVM.StackItems_Push(_handle, ((INativeStackItem)item).Handle); }