Beispiel #1
0
        private void Sort(long start, long number, KeyString keyfunction)
        {
            PTypeSequence pts = (PTypeSequence)typ;

            if (number < 2)
            {
                return;             // сортировать не нужно
            }
            if (number < 10000000)
            {
                // Указатель на начальный элемент и размер головы записи
                PxEntry e    = this.Element(start);
                long    p0   = e.offset;
                int     size = pts.ElementType.HeadSize;
                // организуем массивы ключей и индексов - номеров записей
                string[] keys    = new string[number];
                int[]    indexes = Enumerable.Range(0, (int)number).ToArray();
                // Вычислим и запишем ключи

                for (long ii = 0; ii < number; ii++)
                {
                    keys[ii]  = keyfunction(e);
                    e.offset += size;
                }
                // Сортируем два массива
                Array.Sort(keys, indexes);
                ReorderSequenceArrayHeads(number, p0, size, indexes);
            }
            else
            {
            }
        }
Beispiel #2
0
        private byte[] ValidateKeyString()
        {
            byte[] key;
            switch (KeyFormat)
            {
            case TextFormatEnum.PlainText:
                if (KeyString.Length >= 8)
                {
                    key = Encoding.Default.GetBytes(KeyString).Take(8).ToArray();     // take 8 first bytes to get 64 bit key
                }
                else
                {
                    throw new Exception("Key is too short");
                }
                break;

            case TextFormatEnum.Hexadecimal:
                byte[] tmp = KeyString.ConvertHexadecimalStringToByteArray();
                if (tmp.Count() == 8)
                {
                    key = tmp;
                }
                else
                {
                    throw new Exception("Key is too short");
                }
                break;

            default:
                key = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                break;
            }
            return(key);
        }
Beispiel #3
0
        public CaseModel Func_DeleteKey()
        {
            return(new CaseModel()
            {
                NameSign = @"删除键",
                ExeEvent = () => {
                    string section = RandomData.Item(new List <string>(this.dic.Keys));
                    VerifyIList <KeyString, KeyString> verify = new VerifyIList <KeyString, KeyString>(CalcWayEnum.DoubleCycle)
                    {
                        Func_isEquals = (a, s) => a.Key == s.Key && a.Value == s.Value,
                    };
                    verify.Answer = this.dic[section];
                    verify.Source = this.ini.GetKeyValues(section);
                    if (!verify.Calc())
                    {
                        return false;
                    }

                    KeyString ks = RandomData.Item(this.dic[section]);
                    List <KeyString> kss = new List <KeyString>(this.dic[section]);
                    kss.Remove(ks);
                    this.dic[section] = kss.ToArray();
                    this.ini.DeleteKey(section, ks.Key);

                    verify.Answer = this.dic[section];
                    verify.Source = this.ini.GetKeyValues(section);
                    if (!verify.Calc())
                    {
                        return false;
                    }
                    return true;
                },
            });
        }
        public KeyString setString(string key, string value)
        {
            KeyString ks = getString(key, true);

            ks.value = value;
            return(ks);
        }
Beispiel #5
0
        public CaseModel Func_GetValue_SetValue()
        {
            return(new CaseModel()
            {
                NameSign = @"获取/设置值",
                ExeEvent = () => {
                    GS answer = new GS()
                    {
                        Age = RandomData.GetInt(),
                        DateOfBirth = RandomData.GetDateTime(),
                        Name = RandomData.GetChineseString(),
                        Price = RandomData.GetDouble(),
                        Sex = RandomData.Item(EnumInfo.GetALLItem <GS.SexEnum>()),
                    };

                    GS result = new GS();

                    ShineUponParser parser = new ShineUponParser(typeof(GS));
                    foreach (ShineUponInfo info in parser.GetDictionary().Values)
                    {
                        KeyString ks = parser.GetValue_KeyString(info, answer);
                        parser.SetValue_Object(info, result, ks.Value);
                    }

                    return true;
                },
            });
        }
Beispiel #6
0
 public LookupModuleMessage(KeyString dataOwnerKey, KeyString moduleKey, SemanticVersionNumber dataOwnerVersion = null, SemanticVersionNumber moduleVersion = null)
 {
     DataOwnerKey     = dataOwnerKey;
     DataOwnerVersion = dataOwnerVersion;
     ModuleKey        = moduleKey;
     ModuleVersion    = moduleVersion;
 }
Beispiel #7
0
 public override void Runing()
 {
     GiveLast = false;
     OutRoom  = LastRoom;
     KeyString.Clear();
     KeyNames.Clear();
     foreach (var item in Controller.ControllerKeys)
     {
         KeyString.Add(string.Format("<{0}>:   <{1}>", item.Key, item.Value));
         KeyNames.Add(item.Key);
     }
     SelectIndex = 0;
     DeBugRun();
     SelectIndex = PrintHelper.PrintSelectText(KeyString, SelectIndex);
     if (SelectIndex > KeyString.Count - 1)
     {
         string KeySave = Newtonsoft.Json.JsonConvert.SerializeObject(Controller.ControllerKeys);
         JsonHelper.SaveMyJson(Directory.GetCurrentDirectory(), KeySave, "KeySetting");
         return;
     }
     else
     {
         Console.Clear();
         Console.WriteLine("请按下你想要使用的按键");
         Controller.ControllerKeys[KeyNames[SelectIndex]] = Console.ReadKey().Key;
         OutRoom = this;
     }
 }
Beispiel #8
0
        public void Sort(KeyString keyfunction)
        {
            if (typ.Vid != PTypeEnumeration.sequence)
            {
                throw new Exception("Sort can't be implemented to this vid");
            }
            PTypeSequence pts  = (PTypeSequence)typ;
            long          llen = this.Count();

            if (llen < 2)
            {
                return;           // сортировать не нужно
            }
            // Указатель на нулевой элемент и размер головы записи
            long p0   = this.Element(0).offset;
            int  size = pts.ElementType.HeadSize;

            // организуем массивы ключей и индексов - номеров записей
            string[] keys    = new string[llen];
            int[]    indexes = Enumerable.Range(0, (int)llen).ToArray();
            // Вычислим и запишем ключи
            int i = 0;

            foreach (PxEntry e in this.Elements())
            {
                keys[i] = keyfunction(e);
                i++;
            }
            // Сортируем два массива
            Array.Sort(keys, indexes);
            ReorderSequenceArrayHeads(llen, p0, size, indexes);
        }
Beispiel #9
0
 /// <summary>
 /// Looks up a possibly dormant saga child.
 /// </summary>
 /// <param name="workflowKey"></param>
 /// <param name="version"></param>
 /// <returns></returns>
 private IActorRef LookupSaga(KeyString sagaKey)
 {
     if (_sagas.TryGetValue(sagaKey, out IActorRef sagaActorRef))
     {
         return(sagaActorRef);
     }
     return(ActorRefs.Nobody);
 }
Beispiel #10
0
 public NodeData(string description, JsonSchema dataJsonSchema, KeyString behaviorModuleKey, KeyString behaviorKey, SemanticVersionNumber behaviorVersion, JsonValue behaviorConfiguration)
 {
     Description           = description;
     BehaviorKey           = behaviorKey;
     BehaviorVersion       = behaviorVersion;
     BehaviorConfiguration = behaviorConfiguration;
     DataJsonSchema        = dataJsonSchema;
 }
Beispiel #11
0
        public void TextEscaped(string text)
        {
            this.text = text;
            pressed   = false;

            KeyString.StopRecording(true);

            SetCatchUpdate(null);
        }
Beispiel #12
0
 public LookupWorkflowMessage(KeyString dataOwnerKey, KeyString moduleKey, KeyString workflowKey, SemanticVersionNumber dataOwnerVersion = null, SemanticVersionNumber moduleVersion = null, SemanticVersionNumber workflowVersion = null)
 {
     DataOwnerKey     = dataOwnerKey;
     DataOwnerVersion = dataOwnerVersion;
     ModuleKey        = moduleKey;
     ModuleVersion    = moduleVersion;
     WorkflowKey      = workflowKey;
     WorkflowVersion  = workflowVersion;
 }
        public void KeyString_Serialization()
        {
            KeyString keyString = new KeyString(Guid.NewGuid().ToString());

            string output = JsonConvert.SerializeObject(keyString);

            KeyString deserializedKeyString = JsonConvert.DeserializeObject <KeyString>(output);

            deserializedKeyString.ShouldBe(keyString);
        }
Beispiel #14
0
        public void Enter()
        {
            //enter type mode
            pressed = true;

            KeyString.StartRecording(TextEntered, text, true, -1, keyCollection, maxLength);
            KeyString.KeyStringEscaped = TextEscaped;

            SetCatchUpdate(Update);
        }
        internal const long InitialCacheVersion  = 0;          //初始的缓存数据CacheVersion
        /// <summary>
        /// 主键查找
        /// </summary>
        /// <param name="msgId">数据类型ID</param>
        /// <param name="key">主键</param>
        /// <returns>查找成功返回对应数据对象,不存在返回null</returns>
        internal InnerCacheItem Find(int msgId, KeyString key)
        {
            InnerCacheTable cacheTable = null;

            m_CacheTableDict.TryGetValue(msgId, out cacheTable);
            if (cacheTable != null)
            {
                return(cacheTable.Find(key));
            }
            return(null);
        }
        /// <summary>
        /// 外键查找
        /// </summary>
        /// <param name="msgId">数据类型ID</param>
        /// <param name="key">外键</param>
        /// <returns></returns>
        internal List <InnerCacheItem> FindByForeignKey(int msgId, KeyString foreignKey)
        {
            InnerCacheTable cacheTable = null;

            m_CacheTableDict.TryGetValue(msgId, out cacheTable);
            if (cacheTable != null)
            {
                return(cacheTable.FindByForeignKey(foreignKey));
            }
            return(new List <InnerCacheItem>());
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="msgId">数据类型ID</param>
        /// <param name="key">Key</param>
        /// <returns>删除成功返回true,失败返回false</returns>
        internal bool Remove(int msgId, KeyString key)
        {
            InnerCacheTable cacheTable = null;

            m_CacheTableDict.TryGetValue(msgId, out cacheTable);
            if (cacheTable != null)
            {
                return(cacheTable.Remove(key));
            }
            return(false);
        }
        public void train(string xmlFile)
        {
            if (!(KeyString == "" && ContextBefore == "" && ContextAfter == ""))
            {
                EntityPattern entityP = EntityPattern.load(xmlFile);

                if (entityP.OnlyPattern)
                {
                    string CA = $"(?=({ContextAfter}))";
                    string CB = $"(?<=({ContextBefore}))";
                    string pattern;
                    string div;
                    double keySize = KeyString.Split(' ').Length;
                    if (KeyCounts)
                    {
                        pattern = KeyString;
                        div     = " ";
                    }
                    else
                    {
                        pattern = $" ([^ ]+ ){{{(int)(keySize/2)},{(int)(keySize*3/2)}}}?";
                        div     = "";
                    }
                    if (AfterContextCounts)
                    {
                        pattern = $"{pattern}{div}{CA}";
                    }
                    if (BeforeContextCounts)
                    {
                        pattern = $"{CB}{div}{pattern}";
                    }
                    entityP.Patterns.Add(pattern);
                }
                else
                {
                    if (KeyCounts)
                    {
                        entityP.Patterns.Add(KeyString);
                    }
                    if (AfterContextCounts)
                    {
                        entityP.ContextsAfter.Add(ContextAfter);
                    }
                    if (BeforeContextCounts)
                    {
                        entityP.ContextsBefore.Add(ContextBefore);
                    }
                }

                entityP.save(xmlFile);
            }
        }
        /// <summary>
        /// Returns the SagaStepBehavior requested and null if
        /// </summary>
        /// <param name="behaviorName"></param>
        /// <param name="version"></param>
        /// <param name="behaviorConfiguration"></param>
        /// <returns></returns>
        public ISagaStepBehavior GetSagaStepBehavior(KeyString behaviorName, VersionNumber version, JsonValue behaviorConfiguration)
        {
            ISagaStepBehavior sagaStepBehavior = _pluginSagaStepBehaviorFactory.GetInstance(behaviorName, version);

            if (sagaStepBehavior != null)
            {
                if (!sagaStepBehavior.SetBehaviorConfiguration(behaviorConfiguration))
                {
                    throw new WorkflowRuntimeException($"The supplied behaviorConfiguration is not valid");
                }
            }
            return(sagaStepBehavior);
        }
            public void Throws_exception_for_string_keys(IDialect dialect)
            {
                using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
                {
                    // Arrange
                    var entity = new KeyString {
                        Name = "Some Name", Age = 10
                    };

                    // Act / Assert
                    Assert.Throws <InvalidPrimaryKeyException>(() => database.Insert <string>(entity));
                }
            }
Beispiel #21
0
        public void TextEntered(string text)
        {
            this.text = text;
            pressed   = false;

            if (ValueChanged != null)
            {
                ValueChanged(text);
            }

            KeyString.StopRecording(true);

            SetCatchUpdate(null);
        }
        /// <summary>
        /// 主键查询
        /// </summary>
        /// <param name="key">主键</param>
        /// <returns>若查找到返回唯一对应数据值,否则返回null</returns>
        internal InnerCacheItem Find(KeyString key)
        {
            InnerCacheItem cacheItem = null;

            m_PrimaryDict.TryGetValue(key, out cacheItem);
            if (cacheItem != null && cacheItem.Valid)
            {
                return(cacheItem);
            }
            else
            {
                return(null);
            }
        }
Beispiel #23
0
 /// <summary>
 /// Looks up an active Workflow child. If version is not supplied the highest version is returned
 /// </summary>
 /// <param name="workflowKey"></param>
 /// <param name="version"></param>
 /// <returns></returns>
 private IActorRef LookupWorkflow(KeyString workflowKey, SemanticVersionNumber version = null)
 {
     if (_workflows.TryGetValue(workflowKey, out Dictionary <SemanticVersionNumber, IActorRef> versions))
     {
         if (version == null && versions != null)
         {
             return(versions[versions.Max(v => v.Key)]);
         }
         else if (versions != null && versions.TryGetValue(version, out IActorRef actorRef))
         {
             return(actorRef);
         }
     }
     return(ActorRefs.Nobody);
 }
            public void Inserts_entities_with_string_key(IDialect dialect)
            {
                using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
                {
                    // Arrange
                    var entity = new KeyString {
                        Name = "Some Name", Age = 10
                    };

                    // Act
                    database.Insert(entity);

                    // Assert
                    database.Count <KeyString>().Should().Be(1);
                }
            }
            public void Does_not_allow_string_key_to_be_null(IDialect dialect)
            {
                using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
                {
                    // Arrange
                    var entity = new KeyString {
                        Name = null, Age = 10
                    };

                    // Act
                    Action act = () => database.Insert(entity);

                    // Assert
                    act.Should().Throw <Exception>();
                }
            }
        /// <summary>
        /// 添加或更新
        /// </summary>
        /// <param name="msgId">数据类型ID</param>
        /// <param name="key">Key</param>
        /// <param name="dataMessage">待添加的数据对象</param>
        internal void AddOrUpdate(int msgId, KeyString key, KeyString foreignKey, byte[] dataMessage, long cacheVersion = InnerCacheSystem.InitialCacheVersion)
        {
            InnerCacheTable tableCache = null;

            m_CacheTableDict.TryGetValue(msgId, out tableCache);
            if (tableCache != null)
            {
                tableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion);
            }
            else
            {
                InnerCacheTable newTableCache = new InnerCacheTable();
                newTableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion);
                m_CacheTableDict.Add(msgId, newTableCache);
            }
        }
            public void Throws_exception_for_string_keys(IDialect dialect)
            {
                using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
                {
                    // Arrange
                    var entity = new KeyString {
                        Name = "Some Name", Age = 10
                    };

                    // Act
                    Func <Task> act = async() => await database.InsertAsync <string>(entity);

                    // Assert
                    act.Should().Throw <InvalidPrimaryKeyException>();
                }
            }
        public string Decrypt(string str, string k)
        {
            KeyString key = new KeyString(k);
            string    res = "";
            int       tmp;

            for (int i = 0; i < str.Length; i++)
            {
                tmp = symbolTable.IndexOf(str[i]) - symbolTable.IndexOf(key.GetNextChar());
                if (tmp < 0)
                {
                    tmp += symbolTable.GetSize();
                }
                res += symbolTable.CharAt(tmp);
            }

            return(res);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key">主键</param>
        /// <returns>删除成功返回true,失败为false</returns>
        internal bool Remove(KeyString key)
        {
            KeyString foreignKey = null;

            m_PrimaryForeignDict.TryGetValue(key, out foreignKey);
            if (!KeyString.IsNullOrEmpty(foreignKey))
            {
                HashSet <KeyString> priKeys = null;
                m_ForeignPrimaryDict.TryGetValue(foreignKey, out priKeys);
                if (priKeys != null)
                {
                    priKeys.Remove(key);
                }
                m_ForeignPrimaryDict.Remove(foreignKey);
            }
            m_PrimaryForeignDict.Remove(key);
            return(m_PrimaryDict.Remove(key));
        }
Beispiel #30
0
        public override void Update()
        {
            if (visible)
            {
                UpdateBegin();

                if (pressed)
                {
                    if (!hover && Input.mbLeft._pressed)
                    {
                        TextEntered(KeyString.keyString);
                    }
                    else
                    {
                        if (hover && Input.mbLeft._pressed)
                        {
                            setCursor = true;
                        }

                        if (Input.mbLeft._released)
                        {
                            setCursor = false;
                        }

                        if (setCursor)
                        {
                            KeyString.UpdateMouse(mbPos - posG, font);
                        }
                        text = KeyString.keyString;
                    }
                }
                else if (hover)
                {
                    if (Input.mbLeft.pressed)
                    {
                        Enter();
                    }
                    else if (Input.mbRight.pressed && PressRight != null)
                    {
                        PressRight();
                    }
                }
            }
        }
Beispiel #31
0
            public void PropertySet(WorldObject wo)
            {
                ObjectClass = wo.ObjectClass.ToString();

                foreach (var key in wo.BoolKeys)
                {
                    KeyBool kb = new KeyBool();
                    kb.Key = key;
                    kb.bValue = wo.Values((BoolValueKey)key);
                    BoolVals.Add(kb);

                    if(!MasterKeyClass.BoolKeys.Contains(key)){MasterKeyClass.BoolKeys.Add(key);}
                }

                foreach (var key in wo.DoubleKeys)
                {
                    KeyDouble kd = new KeyDouble();
                    kd.Key = key;
                    kd.dValue =  wo.Values((DoubleValueKey)key);
                    DoubleVals.Add(kd);

                    if(!MasterKeyClass.DoubleKeys.Contains(key)){MasterKeyClass.DoubleKeys.Add(key);}
                }

                foreach (var key in wo.LongKeys)
                {
                    KeyLong kl = new KeyLong();
                    kl.Key = key;
                    kl.lValue = wo.Values((LongValueKey)key);
                    LongVals.Add(kl);

                    if(!MasterKeyClass.LongKeys.Contains(key)){MasterKeyClass.LongKeys.Add(key);}
                }

                foreach (var key in wo.StringKeys)
                {
                    KeyString ks = new KeyString();
                    ks.Key = key;
                    ks.sValue = wo.Values((StringValueKey)key);
                    StringVals.Add(ks);

                    if(!MasterKeyClass.StringKeys.Contains(key)){MasterKeyClass.StringKeys.Add(key);}
                }

                for (int i = 0; i < wo.SpellCount; i++)
                {
                    SpellVals.Add(wo.Spell(i));
                }
            }