public void Init()
 {
     SignerPublicKey = new Hash();
     BallotHash = new Hash();
     Signature = new Hash();
     LedgerCloseSequence = 0;
 }

        /// <summary>
        /// Метод реализующий авторизацию пользователя. Принимает 2 параметра: логин и пароль. Задаёт метод щифрования и устанавливает соединение с БД, передавая принятые параметры.
        /// Возрашает Boolean соединения.
        /// </summary>
        /// <param name="user">Логин</param>
        /// <param name="pass">Пароль</param>
        /// <returns>Успех или крах авторизации</returns>
        public static bool Authorization(string user, string pass)
        {
            //Задаём алгоритм хэширования пасса
            HashType = Hash.SHA1;

            MySqlDataReader dataReaderTemp = MySQL.UserAut(user, pass);
            while (dataReaderTemp.Read())
            {
                Id = dataReaderTemp.GetInt32("id_user");
                Login = dataReaderTemp.GetString("login_user");
                Role = dataReaderTemp.GetString("role");
            }

            if (!dataReaderTemp.HasRows)
            {
                MySQL.connection.Close();
                return false;
            }
            bool toReturn = false;
            switch (HashType)
            {
                case Hash.SHA1:
                    if (sha1(pass) == dataReaderTemp.GetString("pass_user"))
                        toReturn = true;
                    break;
                case Hash.MD5:
                    if (md5(pass) == dataReaderTemp.GetString("pass_user"))
                        toReturn = true;
                    break;
            }
            MySQL.connection.Close();
            MemoryManagement.FlushMemory();
            return toReturn;
        }

        public HeaderHash(Hash hash = null)
        {
            _names = new Dictionary<string, string>();

            hash = hash ?? new Hash();
            hash.Each(pair => this[pair.Key] = pair.Value);
        }

        public bool Compile(string path, string compileToFilePath = null)
        {
            using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read))
            {

                foreach (var kv in _config.CodeTemplates)
                {
                    var templateStr = kv.Key;
                    var exportPath = kv.Value;

                    // 生成代码
                    var template = Template.Parse(templateStr);
                    var topHash = new Hash();
                    topHash["NameSpace"] = _config.NameSpace;
                    var files = new List<Hash>();
                    topHash["Files"] = files;

                    var hash = DoCompiler(path, stream, compileToFilePath);
                    files.Add(hash);

                    if (!string.IsNullOrEmpty(exportPath))
                        File.WriteAllText(exportPath, template.Render(topHash));
                }

            }

            return true;
        }

 public static Hash Decode(IByteReader stream)
 {
     Hash decodedHash = new Hash();
       int Hashsize = 32;
       decodedHash.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Hashsize);
     return decodedHash;
 }

 public LeafDataType this[Hash hash]
 {
     get
     {
         return Values[hash];
     }
 }

        public static Hash/*!*/ Initialize([NotNull]BlockParam/*!*/ defaultProc, Hash/*!*/ self) {
            Assert.NotNull(self, defaultProc);

            self.DefaultProc = defaultProc.Proc;
            self.DefaultValue = null;
            return self;
        }

 public NetworkPacket(Hash publicKey_Src, PacketType type, byte[] Data)
 {
     PublicKeySource = publicKey_Src;
     Type = type;
     this.Data = Data;
     Token = new Hash();
 }

        public async Task<Package> GetAsync(long id, SemanticVersion version, Hash hash)
        {
            var key = prefix + id.ToString() + "/" + version.ToString();

            var ms = new MemoryStream();

            using (var blob = await bucket.GetAsync(key))
            {
                using (var data = blob.Open())
                {
                    await data.CopyToAsync(ms).ConfigureAwait(false);
                }
            }

            ms.Position = 0;
            
            var secret = SecretKey.Derive(password, hash.Data);

            var protector = new AesProtector(secret); // dispose?

            var stream = protector.DecryptStream(ms);

            #region Verify the hash

            var computedHash = Hash.ComputeSHA256(stream, true);

            if (computedHash != hash)
            {
                throw new IntegrityException(hash.Data, computedHash.Data);
            }

            #endregion

            return ZipPackage.FromStream(stream, false);
        }

 public NodeSocketData(Hash PublicKey, int ListenPort, string IP, string Name)
 {
     this.PublicKey = PublicKey;
     this.ListenPort = ListenPort;
     this.IP = IP;
     this.Name = Name;
 }

        public RemoteReferenceData(string name, Hash hash)
        {
            Verify.Argument.IsNeitherNullNorWhitespace(name, "name");

            _name = name;
            _hash = hash;
        }

        /* This function (for internal use only) locates an element in an
        ** hash table that matches the given key.  The hash for this key has
        ** already been computed and is passed as the 4th parameter.
        */
        static HashElem findElementGivenHash(
            Hash pH,       /* The pH to be searched */
            string pKey,   /* The key we are searching for */
            int nKey,      /* Bytes in key (not counting zero terminator) */
            u32 h         /* The hash for this key. */
            )
        {
            HashElem elem;                /* Used to loop thru the element list */
              int count;                    /* Number of elements left to test */

              if ( pH.ht != null && pH.ht[h] != null )
              {
            _ht pEntry = pH.ht[h];
            elem = pEntry.chain;
            count = (int)pEntry.count;
              }
              else
              {
            elem = pH.first;
            count = (int)pH.count;
              }
              while ( count-- > 0 && ALWAYS( elem ) )
              {
            if ( elem.nKey == nKey && elem.pKey.Equals( pKey, StringComparison.InvariantCultureIgnoreCase ) )
            {
              return elem;
            }
            elem = elem.next;
              }
              return null;
        }

		public bool Exists(Hash hash)
		{
			if (files.ContainsKey(hash)) return true;

			if (CheckAndAddOneFile(hash)) return true;
			return false;
		}

        public RemoteBranchData(string name, Hash sha1)
        {
            Verify.Argument.IsNeitherNullNorWhitespace(name, "name");

            _name = name;
            _sha1 = sha1;
        }

        public void Given_a_sequence_validation_transcoder_When_writen_to_the_transcoding_stream_Then_the_inner_stream_contains_the_previous_identifier_followed_by_the_data_written()
        {
            byte[] hashBytes = { 1, 2, 3, 4 };
            const string TestText = "Test";

            var hash = new Hash(hashBytes);
            var previousEventHashReader = new PreviousEventHashReader(hash);
            var sequenceValidationTranscodingStreamFactory = new SequenceValidationTranscodingStreamFactory(previousEventHashReader);

            using (var innerStream = new MemoryStream())
            using (var sequenceValidationTranscodingStream = sequenceValidationTranscodingStreamFactory.CreateTrancodingStream(innerStream))
            {
                var writer = new StreamWriter(sequenceValidationTranscodingStream);
                writer.Write(TestText);
                writer.Flush();
                sequenceValidationTranscodingStream.Flush();

                innerStream.Seek(0, SeekOrigin.Begin);

                var hashBuffer = new byte[4];
                innerStream.Read(hashBuffer, 0, 4);
                var reader = new StreamReader(innerStream);
                var actualText = reader.ReadToEnd();

                CollectionAssert.AreEqual(hashBytes, hashBuffer);
                Assert.AreEqual(TestText, actualText);
            }
        }

 public void Initialize()
 {
     CoolHashFunctionByMe coolHash = new CoolHashFunctionByMe();
     tableString = new Hash<string>(coolHash);
     BoringStandartHashFunction boringHash = new BoringStandartHashFunction();
     tableInt = new Hash<int>(boringHash);
 }

 private static Hash CreateDefaultTagMapping(RubyContext/*!*/ context) {
     Hash taggedClasses = new Hash(context.EqualityComparer);
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:array"), context.GetClass(typeof(RubyArray)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:exception"), context.GetClass(typeof(Exception)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:hash"), context.GetClass(typeof(Hash)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:object"), context.GetClass(typeof(object)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:range"), context.GetClass(typeof(Range)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:regexp"), context.GetClass(typeof(RubyRegex)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:string"), context.GetClass(typeof(MutableString)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:struct"), context.GetClass(typeof(RubyStruct)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:sym"), context.GetClass(typeof(SymbolId)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:symbol"), context.GetClass(typeof(SymbolId)));
     taggedClasses.Add(MutableString.Create("tag:ruby.yaml.org,2002:time"), context.GetClass(typeof(DateTime)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:binary"), context.GetClass(typeof(MutableString)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:bool#no"), context.FalseClass);
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:bool#yes"), context.TrueClass);
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:float"), context.GetClass(typeof(Double)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:int"), context.GetClass(typeof(Integer)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:map"), context.GetClass(typeof(Hash)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:null"), context.NilClass);            
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:seq"), context.GetClass(typeof(RubyArray)));            
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:str"), context.GetClass(typeof(MutableString)));
     taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:timestamp"), context.GetClass(typeof(DateTime)));
     //Currently not supported
     //taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:omap"), ec.GetClass(typeof()));
     //taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:pairs"),//    ec.GetClass(typeof()));
     //taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:set"),//    ec.GetClass(typeof()));
     //taggedClasses.Add(MutableString.Create("tag:yaml.org,2002:timestamp#ymd'"), );
     return taggedClasses;
 }

 public static Hash FromDynamic(dynamic source)
 {
     var result = new Hash();
     if (source != null)
     {
         if (source is ExpandoObject)
         {
             return Hash.FromDictionary((IDictionary<string, object>)source);
         }
         var type = (Type)source.GetType();
         if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(type))
         {
             throw new NotImplementedException("I don't feel like coding this up right now; use a static type?");
         }
         PropertyInfo[] properties;
         if (CachedStatics.ContainsKey(type))
         {
             properties = CachedStatics[type];
         }
         else
         {
             properties = type.GetProperties();
             CachedStatics.Add(type, properties);
         }
         foreach (var property in properties)
         {
             result[property.Name] = property.GetValue(source, null);
         }
     }
     return result;
 }

 /// <summary>
 /// Check whether the given PK is already connected.
 /// </summary>
 /// <param name="PublicKey"></param>
 /// <returns></returns>
 public bool IsConnected(Hash PublicKey)
 {
     if (IncomingConnections.ContainsKey(PublicKey))
     {
         return true;
     }
     else return false;
 }

    /*
    ** 2001 September 22
    **
    ** The author disclaims copyright to this source code.  In place of
    ** a legal notice, here is a blessing:
    **
    **    May you do good and not evil.
    **    May you find forgiveness for yourself and forgive others.
    **    May you share freely, never taking more than you give.
    **
    *************************************************************************
    ** This is the implementation of generic hash-tables
    ** used in SQLite.
    *************************************************************************
    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
    **  C#-SQLite is an independent reimplementation of the SQLite software library
    **
    **  SQLITE_SOURCE_ID: 2010-08-23 18:52:01 42537b60566f288167f1b5864a5435986838e3a3
    **
    *************************************************************************
    */
    //#include "sqliteInt.h"
    //#include <assert.h>

    /* Turn bulk memory into a hash table object by initializing the
    ** fields of the Hash structure.
    **
    ** "pNew" is a pointer to the hash table that is to be initialized.
    */
    static void sqlite3HashInit( Hash pNew )
    {
      Debug.Assert( pNew != null );
      pNew.first = null;
      pNew.count = 0;
      pNew.htsize = 0;
      pNew.ht = null;
    }