Retrieves the child entries of the given node from the server.<p>

@param entryId the entry id
@param setOpen if the entry should be opened

@param callback the callback to execute after the children have been loaded
768363
public void getChildren(
        final CmsUUID entryId,
        final boolean setOpen,
        final AsyncCallback<CmsClientSitemapEntry> callback) {

        getChildren(entryId, setOpen, false, callback);

    }
84311
void removeEntry(NodeId nodeId) throws Exception {
		this.entryCache.remove(nodeId);
		this.entries.remove(nodeId);
	}
831074
@Override
  public SeekableByteChannel open(
      final StorageResourceId resourceId, GoogleCloudStorageReadOptions readOptions)
      throws IOException {
    logger.atFine().log("open(%s, %s)", resourceId, readOptions);
    Preconditions.checkArgument(
        resourceId.isStorageObject(), "Expected full StorageObject id, got %s", resourceId);

    // The underlying channel doesn't initially read data, which means that we won't see a
    // FileNotFoundException until read is called. As a result, in order to find out if the object
    // exists, we'll need to do an RPC (metadata or data). A metadata check should be a less
    // expensive operation than a read data operation.
    GoogleCloudStorageItemInfo info;
    if (readOptions.getFastFailOnNotFound()) {
      info = getItemInfo(resourceId);
      if (!info.exists()) {
        throw GoogleCloudStorageExceptions.getFileNotFoundException(
            resourceId.getBucketName(), resourceId.getObjectName());
      }
    } else {
      info = null;
    }

    return new GoogleCloudStorageReadChannel(
        gcs,
        resourceId.getBucketName(),
        resourceId.getObjectName(),
        errorExtractor,
        clientRequestHelper,
        readOptions) {

      @Override
      @Nullable
      protected GoogleCloudStorageItemInfo getInitialMetadata() {
        return info;
      }

      @Override
      protected Storage.Objects.Get createRequest() throws IOException {
        return configureRequest(super.createRequest(), resourceId.getBucketName());
      }
    };
  }
278392
Lockable<SharedBufferNode> getEntry(NodeId nodeId) {
		return entryCache.computeIfAbsent(nodeId, id -> {
			try {
				return entries.get(id);
			} catch (Exception ex) {
				throw new WrappingRuntimeException(ex);
			}
		});
	}
865136
public void setId(Object id) {
	  if (lock == SET) {
		 throw new IllegalStateException("EntryInfo is locked");
	  }
	  /*if (idFlag == SET) {
		 if (tc.isDebugEnabled()) Tr.debug(tc, "Illegal State: tried to set id to "+id+
											   ", but id was already set to "+this.id  );
		  throw new IllegalStateException("id was already set");
	  } */
	  idFlag = SET;
	  this.id = id;
	  if (tc.isDebugEnabled())
		 Tr.debug(tc, "set id=" + id);
   }
332539
public String getEntryId() {
    if (ResourceEntry_Type.featOkTst && ((ResourceEntry_Type)jcasType).casFeat_entryId == null)
      jcasType.jcas.throwFeatMissing("entryId", "de.julielab.jules.types.ResourceEntry");
    return jcasType.ll_cas.ll_getStringValue(addr, ((ResourceEntry_Type)jcasType).casFeatCode_entryId);}
85046
public static void fillEntry(Element element, CmsUUID id, String rootPath, CmsRelationType type) {

        CmsLink link = new CmsLink(CmsXmlCategoryValue.TYPE_VFS_LINK, type, id, rootPath, true);
        // get xml node
        Element linkElement = element.element(CmsXmlPage.NODE_LINK);
        if (linkElement == null) {
            // create xml node if needed
            linkElement = element.addElement(CmsXmlPage.NODE_LINK);
        }
        // update xml node
        CmsLinkUpdateUtil.updateXmlForVfsFile(link, linkElement);
    }
579427
public static void entry(TraceComponent tc, String methodName) {
    if(isTracing()) SibTr.entry(tc, methodName);

  }
1169207
@Override
   protected void entering(NodeData node, int level) throws RepositoryException
   {
      try
      {
         // set name of node as sv:name attribute
         AttributesImpl atts = new AttributesImpl();
         atts.addAttribute(getSvNamespaceUri(), "name", "sv:name", "CDATA", getExportName(node, false));

         contentHandler.startElement(getSvNamespaceUri(), "node", "sv:node", atts);
      }
      catch (SAXException e)
      {
         throw new RepositoryException(e);
      }

   }
216749
public void getResourceState(final CmsUUID structureId, final AsyncCallback<CmsResourceState> callback) {

        CmsRpcAction<CmsResourceState> action = new CmsRpcAction<CmsResourceState>() {

            /**
             * @see org.opencms.gwt.client.rpc.CmsRpcAction#execute()
             */
            @Override
            public void execute() {

                start(0, false);
                getService().getResourceState(structureId, this);
            }

            /**
             * @see org.opencms.gwt.client.rpc.CmsRpcAction#onResponse(java.lang.Object)
             */
            @Override
            protected void onResponse(CmsResourceState result) {

                stop(false);
                callback.onSuccess(result);
            }
        };
        action.execute();
    }
1315361
@SuppressWarnings("unchecked")
  public Query linksToEntryId(String entryId) {
    checkNotEmpty(entryId, "entryId must not be empty.");

    params.put(PARAMETER_LINKS_TO_ENTRY, entryId);

    return (Query) this;
  }
325451
function(id, url, entry, response) {
      return function wait() {
        try {
          (urlData[id].counter > 0) ? setTimeout(wait, WAIT_TIMEOUT) : response.json(entry);
        } catch (error) {
          console.log("   error -".red, "Error openning".yellow, url, error);
        }
      };
    }
433049
public void open(final OperationResult<Void, Exception> onOpen, final OperationResult<Void, Exception> onClose) {

        this.onOpen = onOpen;
        this.onClose = onClose;
        this.sendLink.open();
        this.receiveLink.open();
    }
812108
protected void entering(NodeData node, int level) throws RepositoryException
   {

      try
      {
         if (node.getQPath().getName().equals(Constants.JCR_XMLTEXT))
         {
            // jcr:xmlcharacters
            List<PropertyData> nodeData = dataManager.getChildPropertiesData(node);
            String strValue = "";
            for (PropertyData propertyData : nodeData)
            {
               if (propertyData.getQPath().getName().equals(Constants.JCR_XMLCHARACTERS))
               {
                  strValue = ValueDataUtil.getString(propertyData.getValues().get(0));
               }
            }
            contentHandler.characters(strValue.toCharArray(), 0, strValue.length());
         }
         else
         {
            List<PropertyData> nodeData = dataManager.getChildPropertiesData(node);
            currentAttr = new AttributesImpl();
            for (PropertyData property : nodeData)
            {

               String strValue = "";

               for (ValueData valueData : property.getValues())
               {
                  String strVal = getValueAsStringForExport(valueData, property.getType());
                  if (strVal.equals(""))
                  {
                     continue;
                  }

                  strValue += //NOSONAR
                     MULTI_VALUE_DELIMITER
                        + (property.getType() == PropertyType.BINARY ? strVal : StringConverter.normalizeString(strVal,
                           true));

               }
               // encode node name
               InternalQName internalPropName = ISO9075.encode(property.getQPath().getName());

               currentAttr.addAttribute(internalPropName.getNamespace(), internalPropName.getName(), getExportName(
                        property, true), "CDATA", !strValue.equals("") ? strValue.substring(1) : strValue);
            }

            if (Constants.ROOT_PATH.equals(node.getQPath()))
               contentHandler.startElement(Constants.NS_JCR_URI, Constants.NS_JCR_PREFIX, JCR_ROOT, currentAttr);

            else
               contentHandler.startElement(node.getQPath().getName().getNamespace(), node.getQPath().getName()
                  .getName(), getExportName(node, true), currentAttr);

         }
      }
      catch (SAXException e)
      {
         throw new RepositoryException(e);
      }
      catch (IllegalStateException e)
      {
         throw new RepositoryException(e);
      }
      catch (IOException e)
      {
         throw new RepositoryException(e);
      }
   }
1210003
public void openPageCopyDialog(String id, JavaScriptObject callback) {

        openPageCopyDialog(id, CmsJsUtil.wrapCallback(callback));
    }
427722
private static <T extends Node> Map.Entry<CSNodeWrapper, T> findEntry(Map<CSNodeWrapper, T> map, Integer id) {
        if (id == null) return null;

        for (final Map.Entry<CSNodeWrapper, T> entry : map.entrySet()) {
            if (entry.getKey().getNextNode() != null && entry.getKey().getNextNode().getId().equals(id)) {
                return entry;
            }
        }

        return null;
    }
1102943
def select_entry(self, core_element_id, by_cursor=True):
        """"""
        for row_num, element_row in enumerate(self.list_store):
            # Compare data port ids
            if element_row[self.ID_STORAGE_ID] == core_element_id:
                if by_cursor:
                    self.tree_view.set_cursor(row_num)
                else:
                    self.tree_view.get_selection().select_path((row_num, ))
                break