Explicit entry. Perform ancestor opening operations,
        then parse cache from archive if so configured, and
        synchronize revocation registry to tails tree content.

        :return: current object
358273
async def open(self) -> 'HolderProver':
        

        LOGGER.debug('HolderProver.open >>>')

        await super().open()
        if self.cfg.get('parse-cache-on-open', False):
            Caches.parse(self.dir_cache)

        for path_rr_id in Tails.links(self._dir_tails):
            await self._sync_revoc(basename(path_rr_id))

        LOGGER.debug('HolderProver.open <<<')
        return self
69540
def obtain_ancestor(check = nil, orderby = 'post_title DESC')
      post = obtain_record(check)
      return nil if post.blank?
      p = post.ancestors
      p = p.arrange(:order => orderby.to_sym) if !orderby.blank?
      filter_results(p)
    end
785992
def RecurseKeys(self):
    
    root_key = self.GetRootKey()
    if root_key:
      for registry_key in root_key.RecurseKeys():
        yield registry_key
1279959
def tree_entries(self):
        
        return TreeEntriesDataFrame(self._engine_dataframe.getTreeEntries(), self._session, self._implicits)
514030
def setup_forward_or_backward_execution(self):
        
        if self.backward_execution:
            # pop the return item of this concurrency state to get the correct scoped data
            last_history_item = self.execution_history.pop_last_item()
            assert isinstance(last_history_item, ReturnItem)
            self.scoped_data = last_history_item.scoped_data
            # get the concurrency item for the children execution historys
            concurrency_history_item = self.execution_history.get_last_history_item()
            assert isinstance(concurrency_history_item, ConcurrencyItem)

        else:  # forward_execution
            self.execution_history.push_call_history_item(self, CallType.CONTAINER, self, self.input_data)
            concurrency_history_item = self.execution_history.push_concurrency_history_item(self, len(self.states))
        return concurrency_history_item
800389
def get_ancestor(ancestor_type)
      target_type = {:directory => [Directory],
                     :feature_file => [FeatureFile],
                     :feature => [Feature],
                     :test => [Scenario, Outline, Background],
                     :background => [Background],
                     :scenario => [Scenario],
                     :outline => [Outline],
                     :step => [Step],
                     :table => [Table],
                     :example => [Example],
                     :row => [Row]
      }[ancestor_type]

      raise(ArgumentError, "Unknown ancestor type '#{ancestor_type}'.") if target_type.nil?


      ancestor = self.parent_model

      until target_type.include?(ancestor.class) || ancestor.nil?
        ancestor = ancestor.parent_model
      end


      ancestor
    end
1254923
def entries_in_tree(self, prefix, tree):
        
        for entry in tree.items():
            if prefix:
                new_prefix = prefix + (entry.path.decode(), )
            else:
                new_prefix = (entry.path.decode(), )

            yield (new_prefix, stat.S_ISDIR(entry.mode), entry.sha)
71532
public synchronized Object getCacheKey(EvictionTableEntry evt) //3821 NK begin
    throws IOException,
                    EOFException,
                    FileManagerException,
                    ClassNotFoundException,
                    HashtableOnDiskException {
        Object key = null;
        if (filemgr == null) {
            throw new HashtableOnDiskException("No Filemanager");
        }

        HashtableEntry e = findEntry(evt, RETRIEVE_KEY);
        //TODO: Do we need to increment read_hits and read_requests
        if (e != null)
            key = e.getKey();
        return key;
    }
1091782
def _store_expansion_state(self):
        """"""

        def store_tree_expansion(child_tree_iter, expansion_state):

            tree_item_path = self.history_tree_store.get_path(child_tree_iter)
            history_item = self.get_history_item_for_tree_iter(child_tree_iter)

            # store expansion state if tree item path is valid and expansion state was not stored already
            if tree_item_path is not None:
                # if first element of sub-tree has same history_item as the parent ignore it's expansion state
                if history_item not in expansion_state:
                    expansion_state[history_item] = self.history_tree.row_expanded(tree_item_path)

            for n in range(self.history_tree_store.iter_n_children(child_tree_iter)):
                child_iter = self.history_tree_store.iter_nth_child(child_tree_iter, n)
                store_tree_expansion(child_iter, expansion_state)

        root_iter = self.history_tree_store.get_iter_first()
        if not root_iter:
            return
        current_expansion_state = {}
        # this can be the case when the execution history tree is currently being deleted
        if not self.get_history_item_for_tree_iter(root_iter).state_reference:
            return
        state_machine = self.get_history_item_for_tree_iter(root_iter).state_reference.get_state_machine()
        self._expansion_state[state_machine.state_machine_id] = current_expansion_state
        while root_iter:
            store_tree_expansion(root_iter, current_expansion_state)
            root_iter = self.history_tree_store.iter_next(root_iter)
1229850
def lineage(self):
        
        if not self.parent:
            return [self]
        else:
            L = self.parent.lineage()
            L.append(self)
            return L
1037149
def build_archive(cls, **kwargs):
        
        if cls._archive is None:
            cls._archive = cls(**kwargs)
        return cls._archive
1301849
public synchronized Entry getPreviousEntry()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "getPreviousEntry");
    
    checkEntryParent();
    
    Entry previousEntry = null;
    
    synchronized(parentList)
    {            
      if(atBottom)
      {
        //if at the bottom of the list, return the last entry in the list
        previousEntry = parentList.last;
      }
      else if(!atTop)                        
      {
        //otherwise it's just the previous entry in the list
        previousEntry = current.getPrevious();                        
      }
      //if the cursor is at the top of the list then we should
      //just drop through and the previous entry is null
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "getPreviousEntry", previousEntry);

    return previousEntry;
  }
177029
def _raw_open(self, flags, mode=0o777):
        
        if self._closed:
            self._raise_closed()
        return self._accessor.open(self, flags, mode)
359547
def cenancestor(self):
        
        ancestor = parent = self.parent
        while parent:
            ancestor = parent
            parent = getattr(parent, 'parent', None)
        return ancestor
899471
def open
      @nodes.open
      @cache.clear
      node = @nodes.total_entries == 0 ?
        SpaceTreeNode::create(self) :
        SpaceTreeNode::load(self, @nodes.first_entry)
      @root_address = node.node_address
    end
334278
def append_ancestor_entry(ancestors, ancestor, class_methods, instance_methods = nil)
      if class_methods || instance_methods
        ancestor_entry = {}
        ancestor_entry[:class] = class_methods if class_methods
        ancestor_entry[:instance] = instance_methods if instance_methods
        ancestors << {ancestor => ancestor_entry}
      end
    end
326519
private void open() {
    // Load existing log segments from disk.
    for (Segment segment : loadSegments()) {
      segments.put(segment.descriptor().index(), segment);
    }

    // If a segment doesn't already exist, create an initial segment starting at index 1.
    if (!segments.isEmpty()) {
      currentSegment = segments.lastEntry().getValue();
    } else {
      SegmentDescriptor descriptor = SegmentDescriptor.builder()
        .withId(1)
        .withVersion(1)
        .withIndex(1)
        .withMaxSegmentSize(storage.maxSegmentSize())
        .withMaxEntries(storage.maxEntriesPerSegment())
        .build();

      descriptor.lock();

      currentSegment = createSegment(descriptor);
      currentSegment.descriptor().update(System.currentTimeMillis());
      currentSegment.descriptor().lock();

      segments.put(1L, currentSegment);
    }
  }