public bool TryGet(IKey key, out IEntry entry)
 {
     Entry tempEntry;
     var result = _entries.TryGetValue(key, out tempEntry) && !tempEntry.IsReserved;
     entry = result ? tempEntry : null;
     return result;
 }

        public bool deletePair(IKey key, bool firstCall = false)
        {
            bool canRemoveKey = true;
            if(firstCall)
                canRemoveKey = m_rkm.removeKey(key);

            if (!canRemoveKey)
                return false;

            bool retVal = m_pairsManager.removePair(key);
            //the key is in the local server
            if (retVal)
            {
                m_pairsManager.saveToDisk();
                return retVal;
            }
            //if key doesn't exists on the server need ask the ring for it
            String serviceAddress = m_nextServer.Channel + "://" + m_nextServer.ServerAddress + ":" + m_nextServer.ServerPort + "/" + m_nextServer.ServiceName;

            //Creating server proxy
            IServer svc = (IServer)Activator.GetObject(
                                    typeof(IServer),
                                    serviceAddress);

            try
            {
                return svc.deletePair(key);
            }
            catch (Exception)
            {
                m_rkm.removeServerFromRKM(m_nextServer);
                return false;
            }
        }

 public void AddKey(IKey key)
 {
     lock (this)
     {
         _keys.AddLast(key.Key);
     }
 }

 /// <summary>
 /// Value equality for two IKey's
 /// </summary>
 /// <returns>true if all parts of of the keys are the same</returns>
 public static bool EqualTo(this IKey key, IKey other)
 {
     return (key.Base == other.Base)
         && (key.TypeName == other.TypeName)
         && (key.ResourceId == other.ResourceId)
         && (key.VersionId == other.VersionId);
 }

        public void DeletePair(IKey key)
        {
            if (_manager.Trykey(key))
                {
                    if (_hashtable.ContainsKey(key.Key))
                    {

                        _manager.RemoveKey(key);
                        _hashtable.Remove(key.Key);
                    }
                    else
                    {
                        bool b = true;
                        while (b)
                        {
                            try
                            {

                                if (_nextserverUri == null) return;
                                _mysuccessorServer.DeletePair(key);
                                b = false;
                            }
                            catch (Exception ex)
                            {
                                if (ex is WebException || ex is RemotingException)
                                {

                                    _manager.RemakeRing(_nextserverUri);
                                }
                            }
                        }
                    }
                }
        }

        async Task<RegisterOperationResult?> TryOneRequest(IKey key, KeyRegisterRequest request,
            CancellationToken cancellationToken)
        {
            try
            {
                var result = await key.RegisterAsync(request, cancellationToken);

                log.Info(result.Status.ToString());
                switch (result.Status)
                {
                    case KeyResponseStatus.Success:
                        return RegisterOperationResult.Success(request, result.Data);
                }
            }
            catch (KeyGoneException)
            {
                // No sense in continuing with this signer, the key isn't physically present anymore
                log.DebugFormat("Key '{0}' is gone", keyId);
                throw;
            }
            catch (TaskCanceledException)
            {
                // Let cancellation bubble up
                throw;
            }
            catch (KeyBusyException)
            {
                // Maybe it won't be busy later
            }
            catch (Exception exception)
            {
                log.Error("Authenticate request failed", exception);
            }
            return null;
        }

 public static void HasTypeName(IKey key)
 {
     if (string.IsNullOrEmpty(key.TypeName))
     {
         throw Error.BadRequest("Resource type is missing: {0}", key);
     }
 }

		public BTree(uint topSid, SegmentManager sm, IKey keyFactory)
		{
			this.m_top_sid = topSid;
			this.m_sgManager = sm;
			this.m_keyFactory = keyFactory;
			this.m_nodeFactory = new BNode();
		}

        public virtual EntityKeyFactory GetKeyFactory(IKey key)
            => _cache.GetOrAdd(
                key,
                k =>
                    {
                        if (k.Properties.Count == 1)
                        {
                            var keyProperty = k.Properties[0];
                            var keyType = keyProperty.ClrType;

                            // Use composite key for anything with structural (e.g. byte[]) properties even if they are
                            // not composite because it is setup to do structural comparisons and the generic typing
                            // advantages of the simple key don't really apply anyway.
                            if (!typeof(IStructuralEquatable).GetTypeInfo().IsAssignableFrom(keyType.GetTypeInfo()))
                            {
                                var sentinel = keyProperty.SentinelValue;

                                return (EntityKeyFactory)(sentinel == null
                                    ? Activator.CreateInstance(
                                        typeof(SimpleNullSentinelEntityKeyFactory<>).MakeGenericType(keyType.UnwrapNullableType()), k)
                                    : Activator.CreateInstance(
                                        typeof(SimpleEntityKeyFactory<>).MakeGenericType(keyType.UnwrapNullableType()), k, sentinel));
                            }
                        }

                        return new CompositeEntityKeyFactory(k);
                    });

        public IEntry Get(IKey key)
        {
            IEntry entry;
            if (TryGet(key, out entry))
                return entry;

            throw new EntryNotFoundException(key);
        }

        public override void Add(string name, IKey key)
        {
            string keyPath = Path.Combine (this.path, name);

            if (File.Exists (keyPath + privateSuffix) || File.Exists (keyPath + publicSuffix))
                throw new ArgumentException ("Key with that name already exists");

            WriteKey (key, name);
        }

        public bool TryRemove(IKey key)
        {
            var fragments = _fragments;
            foreach (var fragment in fragments)
                if (fragment.TableOfContent.Contains(key))
                    return fragment.TryRemove(key);

            return false;
        }

        public bool TryGet(IKey key, out IEntry entry)
        {
            foreach (var fragment in _fragments)
                if (fragment.TableOfContent.TryGet(key, out entry))
                    return true;

            entry = null;
            return false;
        }

 public override IEnumerable<IAnnotation> For(IKey key)
 {
     if (key.SqlServer().IsClustered.HasValue)
     {
         yield return new Annotation(
              SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.Clustered,
              key.SqlServer().IsClustered.Value);
     }
 }

 private void put(IKey key, int level, IEnumerable<Resource> resources)
 {
     if (resources == null) return;
     foreach (var resource in resources)
     {
         if (resource is DomainResource)
         put(key, level, resource as DomainResource);
     }
 }

 protected void Set(IKey key)
 {
     Id = key.Id;
     OwnerUserId = key.OwnerUserId;
     BlobId = key.BlobId;
     Secure = key.Secure;
     if (key.KeyData != null)
         KeyData = (byte[])key.KeyData.Clone();
 }

 public KeyInteractionEventArgs( IKey k, IKeyProgram p, KeyInteractionEventType eventType )
     : base(k)
 {
     EventType = eventType;
     // Clone the commands: the emitted commands is a snapshot of the commands
     // at the time of the event.
     string[] copy = p.Commands.ToArray();
     Commands = new CKReadOnlyListOnIList<string>( copy );
 }

        public bool TryGet(IKey key, out byte[] content)
        {
            foreach (var fragment in _fragments)
                if (fragment.TryGet(key, out content))
                    return true;

            content = null;
            return false;
        }

        protected static Collection<Dictionary<string, string>> ValidateDtoData(IKey dto, EntityBase entity)
        {
            var retVal = new Collection<Dictionary<string, string>>();
            var fieldName = string.Empty;
            foreach (var inputField in dto.GetType().GetProperties().Where(x => x.Name != "Key" && x.GetValue(dto) != null)) {
                if (inputField.Name.StartsWith("Start_")) {
                    fieldName = inputField.Name.Substring(6);
                } else if(inputField.Name.StartsWith("End_")){
                    fieldName = inputField.Name.Substring(4);
                } else if(inputField.Name.Contains("__")) {
                    //  using field from a different table
                    //      not currently handling this case
                } else {
                    fieldName = inputField.Name;
                }
                //  insure the entity contains the field represented by fieldName
                var entityFieldName = entity.GetType().GetProperty(fieldName);
                if (entityFieldName == null || entityFieldName.Name.Length == 0) {
                    //  entity does not contain this field
                    continue;
                }
                if (entity.GetDataType(fieldName) == typeof(string)) {
                    //  should be ok
                    continue;
                }
                if (entity.GetDataType(fieldName) == typeof(int) || entity.GetDataType(fieldName) == typeof(int?)) {
                    var nbr = 0;
                    if (!int.TryParse(inputField.GetValue(dto).ToString(), out nbr)) {

                        var dic = new Dictionary<string, string> {{inputField.Name, "Invalid data type cast"}};
                        retVal.Add(dic);
                    }
                    if (entity.GetDataType(fieldName) == typeof(bool) || entity.GetDataType(fieldName) == typeof(bool?)) {
                        if (inputField.GetValue(dto).ToString().ToLower() != "true" && inputField.GetValue(dto).ToString().ToLower() != "false") {
                            var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
                            retVal.Add(dic);
                        }
                    }
                    if (entity.GetDataType(fieldName) == typeof(DateTime) || entity.GetDataType(fieldName) == typeof(DateTime?)) {
                        DateTime dt;
                        if (!DateTime.TryParse(inputField.GetValue(dto).ToString(), out dt)) {
                            var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
                            retVal.Add(dic);
                        }
                    }
                    if (entity.GetDataType(fieldName) == typeof(decimal) || entity.GetDataType(fieldName) == typeof(decimal?)) {
                        decimal d;
                        if (!decimal.TryParse(inputField.GetValue(dto).ToString(), out d)) {
                            var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
                            retVal.Add(dic);
                        }
                    }
                }
            }
            return retVal;
        }

 private void put(IKey key, int level, Resource resource)
 {
     if (resource is DomainResource)
     {
         DomainResource d = resource as DomainResource;
         put(key, level, d);
         put(key, level + 1, d.Contained);
     }
     
 }