import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public FolderNode getDescendants(String folderId, int depth)
{
    Session session = getCMISSession();

    CmisObject o = session.getObject(folderId);
    if(o instanceof Folder)
    {
        Folder f = (Folder)o;

        OperationContextImpl ctx = new OperationContextImpl();
        List<Tree<FileableCmisObject>> res = f.getDescendants(depth, ctx);
        FolderNode ret = (FolderNode)CMISNode.createNode(f);
        for(Tree<FileableCmisObject> t : res)
        {
            addChildren(ret, t);
        }

        return ret;
    }
    else
    {
        throw new IllegalArgumentException("Folder does not exist or is not a folder");
    }
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public void addChildren(FolderNode f, Tree<FileableCmisObject> t)
{
    FileableCmisObject fco = t.getItem();
    CMISNode child = CMISNode.createNode(fco);

    if(child instanceof FolderNode)
    {
        f.addFolder((FolderNode)child);
        for(Tree<FileableCmisObject> c : t.getChildren())
        {
            addChildren((FolderNode)child, c);
        }
    }
    else
    {
        f.addNode(child);
    }
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public List<Tree<FileableCmisObject>> getFolderTree(String folderId, int depth)
{
    CmisObject o = session.getObject(folderId);
    if(o instanceof Folder)
    {
        Folder f = (Folder)o;

        OperationContextImpl ctx = new OperationContextImpl();
        List<Tree<FileableCmisObject>> res = f.getFolderTree(depth, ctx);
        return res;
    }
    else
    {
        throw new IllegalArgumentException("Object does not exist or is not a folder");
    }
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
private Tree<FileableCmisObject> findTree(String nodeId, List<Tree<FileableCmisObject>> nodes)
{
	Tree<FileableCmisObject> ret = null;

	for(Tree<FileableCmisObject> tree : nodes)
	{
		FileableCmisObject item = tree.getItem();
		// compare only the "bare" object id i.e. without the version suffix
		if(getBareObjectId(nodeId).equals(getBareObjectId(item.getId())))
		{
			ret = tree;
			break;
		}
	}

	return ret;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
private static long doGetFolderTreeSize(Tree<FileableCmisObject> pTree) {
	long lLngSize = 0;

	FileableCmisObject lCurCmisObject = pTree.getItem();
	if (lCurCmisObject instanceof Document) {
		long lLngCurSize = ((Document) lCurCmisObject).getContentStreamLength();
		if (lLngCurSize > -1) {
			lLngSize += lLngCurSize;
		}
		mLog.debug("---------- Dimensione di " + lCurCmisObject.getName() + ": " + lLngCurSize);

	} else {
		for (Tree<FileableCmisObject> tree : pTree.getChildren()) {
			lLngSize += doGetFolderTreeSize(tree);
		}
		mLog.debug("------ Dimensione totale contenuto di " + lCurCmisObject.getName() + ": " + lLngSize);
	}

	return lLngSize;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public void addChildren(FolderNode f, Tree<FileableCmisObject> t)
{
	FileableCmisObject fco = t.getItem();
	CMISNode child = CMISNode.createNode(fco);

	if(child instanceof FolderNode)
	{
		f.addFolder((FolderNode)child);
       	for(Tree<FileableCmisObject> c : t.getChildren())
       	{
       		addChildren((FolderNode)child, c);
       	}
	}
	else
	{
		f.addNode(child);
	}
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public FolderNode getDescendants(String folderId, int depth)
{
	Session session = getCMISSession();

	CmisObject o = session.getObject(folderId);
	if(o instanceof Folder)
	{
		Folder f = (Folder)o;

		OperationContextImpl ctx = new OperationContextImpl();
		List<Tree<FileableCmisObject>> res = f.getDescendants(depth, ctx);
		FolderNode ret = (FolderNode)CMISNode.createNode(f);
       	for(Tree<FileableCmisObject> t : res)
       	{
       		addChildren(ret, t);
       	}

       	return ret;
	}
	else
	{
		throw new IllegalArgumentException("Folder does not exist or is not a folder");
	}
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public List<Tree<FileableCmisObject>> getFolderTree(String folderId, int depth)
{
	CmisObject o = session.getObject(folderId);
	if(o instanceof Folder)
	{
		Folder f = (Folder)o;
	
		OperationContextImpl ctx = new OperationContextImpl();
		List<Tree<FileableCmisObject>> res = f.getFolderTree(depth, ctx);
		return res;
	}
	else
	{
		throw new IllegalArgumentException("Object does not exist or is not a folder");
	}
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
/**
 * Helper for {@link #getCreatableTypes(Session, String)}.
 */
private static void addType(List<Tree<ObjectType>> types,
		List<ObjectType> resultList) {
	for (Tree<ObjectType> tt : types) {
		if (tt.getItem() != null) {
			boolean isCreatable = (tt.getItem().isCreatable() == null ? true
					: tt.getItem().isCreatable().booleanValue());

			if (isCreatable) {
				resultList.add(tt.getItem());
			}

			addType(tt.getChildren(), resultList);
		}
	}
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public static long getFolderTreeSize(Session pSession, String pStrNodeRef) {
	mLog.debug("ENTER getFolderSize(pFolder)");
	long lLngSize = 0;

	Folder lFolder = getFolderById(pSession, pStrNodeRef);
	for (Tree<FileableCmisObject> tree : lFolder.getDescendants(-1)) {
		lLngSize += doGetFolderTreeSize(tree);
	}

	mLog.debug("--- Dimensione totale contenuto di " + lFolder.getName() + ": " + lLngSize);
	mLog.debug("EXIT getFolderSize(pFolder)");
	return lLngSize;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
private static void doGetTypesTreeLeaves(List<Tree<ObjectType>> pTypesTree, List<ObjectType> pLeaves) {
	for (Tree<ObjectType> tree : pTypesTree) {
		List<Tree<ObjectType>> lChildren = tree.getChildren();

		if (lChildren.isEmpty()) {
			pLeaves.add(tree.getItem());

		} else {
			doGetTypesTreeLeaves(lChildren, pLeaves);
		}
	}
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
@Override
public List<TreeNodeDTO<EditorType>> getTypes() {
  List<TreeNodeDTO<EditorType>> nodes = new ArrayList<>();

  for (Tree<ObjectType> tree : cmisProxy.getSession().getTypeDescendants(null, -1, true)) {
    nodes.add(fillWith(tree));
  }

  return nodes;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
private TreeNodeDTO<EditorType> fillWith(Tree<ObjectType> tree) {
  TreeNodeDTO<EditorType> treeNodeDTO = new TreeNodeDTO<>(new EditorType(tree.getItem()));

  List<TreeNodeDTO<EditorType>> children = new ArrayList<>();
  for (Tree<ObjectType> t : tree.getChildren()) {
    children.add(fillWith(t));
  }

  treeNodeDTO.setChildren(children);

  return treeNodeDTO;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
@Override
public List<TreeNodeDTO<FolderDTO>> getTreeView(FolderDTO fromNode) {
  List<Tree<FileableCmisObject>> temp = this.cmisProxy
      .getSession()
      .getRootFolder()
      .getFolderTree(-1);

  if (temp.isEmpty()) {
    return Collections.emptyList();
  } else {
    return temp.stream()
        .map(this::fillObjectTree)
        .collect(Collectors.toList());
  }
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
private TreeNodeDTO<FolderDTO> fillObjectTree(Tree<FileableCmisObject> tree) {
  FolderDTO dto = new FolderDTO();
  dto.setObjectID(tree.getItem().getId());
  dto.setName(tree.getItem().getName());
  dto.setPath(tree.getItem().getPaths().get(0));

  TreeNodeDTO<FolderDTO> node = new TreeNodeDTO<>(dto);

  node.setChildren(tree.getChildren()
      .stream()
      .map(this::fillObjectTree)
      .collect(Collectors.toList()));

  return node;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
/**
 * Returns the creatable descendants types of the given type.
 */
public static List<ObjectType> getCreatableTypes(Session session,
		String rootTypeId) {
	List<ObjectType> result = new ArrayList<ObjectType>();

	// get the root type
	ObjectType rootType = null;
	try {
		rootType = session.getTypeDefinition(rootTypeId);
	} catch (CmisObjectNotFoundException e) {
		return result; // empty
	}

	// get the descendants and add the creatable subtypes
	List<Tree<ObjectType>> types = session.getTypeDescendants(
			rootTypeId, -1, false);
	addType(types, result);

	// finally, add the root type, if it is creatable
	boolean isCreatable = (rootType.isCreatable() == null ? true
			: rootType.isCreatable().booleanValue());
	if (isCreatable) {
		result.add(rootType);
	}

	// sort the list by display name
	Collections.sort(result, new Comparator<ObjectType>() {
		public int compare(ObjectType ot1, ObjectType ot2) {
			return ot1.getDisplayName().compareTo(ot2.getDisplayName());
		}
	});

	return result;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public List<Tree<ObjectType>> getTypeDescendants(String typeId, int depth, boolean includePropertyDefinitions)
{
    List<Tree<ObjectType>> res = session.getTypeDescendants(typeId, depth, includePropertyDefinitions);
    return res;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
/**
 * Recupera l'albero dei tipi documento a partire da un determinato tipo base.
 * <p>
 * Il recupero dei tipi può essere limitato nella profondità.
 * <p>
 * L'albero è senza radice, perciò di fatto è una lista di alberi (ovvero gli alberi sottostanti
 * i figli diretti del tipo base).
 * 
 * @param pSession
 *            la sessione da usare.
 * @param pStrBaseType
 *            il tipo base da cui far partire la ricerca.
 * @param pIntDepth
 *            la profondità massima dell'albero. Deve essere un valore maggiore di 0, o -1 per
 *            una profondità illimitata.
 * @param pBlnIncludeProperties
 *            se {@code true} il risultato comprenderà anche il dettaglio della definizione
 *            delle proprietà.
 * 
 * @return L'albero dei tipi documento.
 */
public static List<Tree<ObjectType>> getTypesTree(Session pSession, String pStrBaseType, int pIntDepth,
        boolean pBlnIncludeProperties) {
	mLog.debug("START getTypesTree(String, int, boolean)");

	List<Tree<ObjectType>> lTypeTree = null;
	try {
		// XXX: Sono dati tendenzialmente stabili, si usa la cache: corretto?
		lTypeTree = pSession.getTypeDescendants(pStrBaseType, pIntDepth, pBlnIncludeProperties);

	} catch (CmisObjectNotFoundException e) {
		// Niente: il tipo non esiste e si restituisce null
		mLog.info("Tipo base '{}' non trovato", pStrBaseType);
	}

	mLog.debug("END getTypesTree(String, int, boolean)");
	return lTypeTree;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
public List<Tree<ObjectType>> getTypeDescendants(String typeId, int depth, boolean includePropertyDefinitions)
{
	List<Tree<ObjectType>> res = session.getTypeDescendants(typeId, depth, includePropertyDefinitions);
	return res;
}
 

import org.apache.chemistry.opencmis.client.api.Tree; //导入依赖的package包/类
/**
 * Recupera la lista dei tipi documento finali a partire da un determinato tipo base.
 * <p>
 * I tipi documento restituiti sono le foglie dell'albero dei tipi discendenti dal tipo base
 * specificato, ovvero i suoi ultimi discendenti.
 * 
 * @param pSession
 *            la sessione da usare.
 * @param pStrBaseType
 *            il tipo base da cui far partire la ricerca.
 * @param pBlnIncludeProperties
 *            se {@code true} il risultato comprenderà anche il dettaglio della definizione
 *            delle proprietà.
 * 
 * @return La lista dei tipi documento.
 */
public static List<ObjectType> getTypesTreeLeaves(Session pSession, String pStrBaseType,
        boolean pBlnIncludeProperties) {
	mLog.debug("START getTypesTreeLeaves(String, int, boolean)");

	List<ObjectType> lLeaves = new LinkedList<ObjectType>();

	List<Tree<ObjectType>> lTypesTree = getTypesTree(pSession, pStrBaseType, -1, pBlnIncludeProperties);
	doGetTypesTreeLeaves(lTypesTree, lLeaves);

	mLog.debug("END getTypesTreeLeaves(String, int, boolean)");
	return lLeaves;
}