private void OnTransferCommand(UInt160 tokenHash, UInt160 to, decimal amount, UInt160 from = null, string data = null, UInt160[] signersAccounts = null) { var snapshot = NeoSystem.StoreView; var asset = new AssetDescriptor(snapshot, NeoSystem.Settings, tokenHash); var value = new BigDecimal(amount, asset.Decimals); if (NoWallet()) { return; } Transaction tx; try { tx = CurrentWallet.MakeTransaction(snapshot, new[] { new TransferOutput { AssetId = tokenHash, Value = value, ScriptHash = to, Data = data } }, from: from, cosigners: signersAccounts?.Select(p => new Signer { // default access for transfers should be valid only for first invocation Scopes = WitnessScope.CalledByEntry, Account = p }) .ToArray() ?? Array.Empty <Signer>()); } catch (InvalidOperationException e) { ConsoleHelper.Error(GetExceptionMessage(e)); return; } if (!ReadUserInput("Relay tx(no|yes)").IsYes()) { return; } SignAndSendTx(snapshot, tx); }
private static Block CreateDummyBlock(StoreView snapshot) { var currentBlock = snapshot.Blocks[snapshot.CurrentBlockHash]; return(new Block { Version = 0, PrevHash = snapshot.CurrentBlockHash, MerkleRoot = new UInt256(), Timestamp = currentBlock.Timestamp + Blockchain.MillisecondsPerBlock, Index = snapshot.Height + 1, NextConsensus = currentBlock.NextConsensus, Witness = new Witness { InvocationScript = Array.Empty <byte>(), VerificationScript = Array.Empty <byte>() }, ConsensusData = new ConsensusData(), Transactions = new Transaction[0] }); }
private static bool GetLinqExpressionsBuiltWithIsInterpretingOnly() { return(!(bool)typeof(LambdaExpression).GetMethod("get_CanCompileToIL").Invoke(null, Array.Empty <object>())); }
public Assembly[] ReflectionOnlyGetAssemblies() => Array.Empty <Assembly>();
public ZINTERSTORE(Key destination, IReadOnlyList <Key> keys, Aggregation aggregation = Aggregation.Sum) : this(destination, keys, Array.Empty <double>(), aggregation) { }
private static List <string> GetResultColumns(HbmReturnProperty returnPropertySchema) { List <string> allResultColumns = new List <string>(); String column = Unquote(returnPropertySchema.column); if (column != null) { allResultColumns.Add(column); } foreach (HbmReturnColumn returnColumnSchema in returnPropertySchema.returncolumn ?? Array.Empty <HbmReturnColumn>()) { allResultColumns.Add(Unquote(returnColumnSchema.name)); } return(allResultColumns); }
private IDictionary <string, string[]> BindPropertyResults(string alias, HbmReturnDiscriminator discriminatorSchema, HbmReturnProperty[] returnProperties, PersistentClass pc) { Dictionary <string, string[]> propertyresults = new Dictionary <string, string[]>(); // maybe a concrete SQLpropertyresult type, but Map is exactly what is required at the moment if (discriminatorSchema != null) { propertyresults["class"] = GetResultColumns(discriminatorSchema).ToArray(); } List <HbmReturnProperty> properties = new List <HbmReturnProperty>(); List <string> propertyNames = new List <string>(); foreach (HbmReturnProperty returnPropertySchema in returnProperties ?? Array.Empty <HbmReturnProperty>()) { string name = returnPropertySchema.name; if (pc == null || name.IndexOf('.') == -1) { //if dotted and not load-collection nor return-join //regular property properties.Add(returnPropertySchema); propertyNames.Add(name); } else { // Reorder properties // 1. get the parent property // 2. list all the properties following the expected one in the parent property // 3. calculate the lowest index and insert the property int dotIndex = name.LastIndexOf('.'); string reducedName = name.Substring(0, dotIndex); IValue value = pc.GetRecursiveProperty(reducedName).Value; IEnumerable <Mapping.Property> parentPropIter; if (value is Component) { Component comp = (Component)value; parentPropIter = comp.PropertyIterator; } else if (value is ToOne) { ToOne toOne = (ToOne)value; PersistentClass referencedPc = mappings.GetClass(toOne.ReferencedEntityName); if (toOne.ReferencedPropertyName != null) { try { parentPropIter = ((Component)referencedPc.GetRecursiveProperty(toOne.ReferencedPropertyName).Value).PropertyIterator; } catch (InvalidCastException e) { throw new MappingException("dotted notation reference neither a component nor a many/one to one", e); } } else { try { parentPropIter = ((Component)referencedPc.IdentifierProperty.Value).PropertyIterator; } catch (InvalidCastException e) { throw new MappingException("dotted notation reference neither a component nor a many/one to one", e); } } } else { throw new MappingException("dotted notation reference neither a component nor a many/one to one"); } bool hasFollowers = false; List <string> followers = new List <string>(); foreach (Mapping.Property prop in parentPropIter) { string currentPropertyName = prop.Name; string currentName = reducedName + '.' + currentPropertyName; if (hasFollowers) { followers.Add(currentName); } if (name.Equals(currentName)) { hasFollowers = true; } } int index = propertyNames.Count; int followersSize = followers.Count; for (int loop = 0; loop < followersSize; loop++) { string follower = followers[loop]; int currentIndex = GetIndexOfFirstMatchingProperty(propertyNames, follower); index = currentIndex != -1 && currentIndex < index ? currentIndex : index; } propertyNames.Insert(index, name); properties.Insert(index, returnPropertySchema); } } var uniqueReturnProperty = new HashSet <string>(); foreach (HbmReturnProperty returnPropertySchema in properties) { string name = returnPropertySchema.name; if ("class".Equals(name)) { throw new MappingException( "class is not a valid property name to use in a <return-property>, use <return-discriminator> instead" ); } //TODO: validate existing of property with the chosen name. (secondpass ) List <string> allResultColumns = GetResultColumns(returnPropertySchema); if (allResultColumns.Count == 0) { throw new MappingException( "return-property for alias " + alias + " must specify at least one column or return-column name" ); } if (uniqueReturnProperty.Contains(name)) { throw new MappingException( "duplicate return-property for property " + name + " on alias " + alias ); } uniqueReturnProperty.Add(name); // the issue here is that for <return-join/> representing an entity collection, // the collection element values (the property values of the associated entity) // are represented as 'element.{propertyname}'. Thus the StringHelper.root() // here puts everything under 'element' (which additionally has significant // meaning). Probably what we need to do is to something like this instead: // String root = StringHelper.root( name ); // String key = root; // by default // if ( !root.equals( name ) ) { // // we had a dot // if ( !root.equals( alias ) { // // the root does not apply to the specific alias // if ( "elements".equals( root ) { // // we specifically have a <return-join/> representing an entity collection // // and this <return-property/> is one of that entity's properties // key = name; // } // } // } // but I am not clear enough on the intended purpose of this code block, especially // in relation to the "Reorder properties" code block above... // String key = StringHelper.root( name ); string key = name; string[] intermediateResults; if (!propertyresults.TryGetValue(key, out intermediateResults)) { propertyresults[key] = allResultColumns.ToArray(); } else { throw new NotImplementedException(); // 2013-02-24: In 89994bc113e1bb35bf6bcd0b7408d08340bfbccd, 2008-05-29, the intermediateResults // variable was changed from ArrayList to string[]. The following code line was there before. // Since an array cannot be modified, it seems this code line has never been hit since then. // While working on NH-3345, I'm adding an ambigous overload for AddAll(), and I don't want to // try to understand this code right now, so comment it out instead. /Oskar //ArrayHelper.AddAll(intermediateResults, allResultColumns); // TODO: intermediateResults not used after this } } Dictionary <string, string[]> newPropertyResults = new Dictionary <string, string[]>(); foreach (KeyValuePair <string, string[]> entry in propertyresults) { newPropertyResults[entry.Key] = entry.Value; } return(newPropertyResults.Count == 0 ? (IDictionary <string, string[]>)CollectionHelper.EmptyDictionary <string, string[]>() : newPropertyResults); }