CloneDocument(ObjectCache,ObjectCache,Uri,CloneDocumentOptions) Method

Summary

Clones (creates a copy) of an uploaded document in the cache.

Syntax

C++/CLI

Python

public static Uri CloneDocument( 
   ObjectCache sourceCache, 
   ObjectCache targetCache, 
   Uri sourceDocumentUri, 
   CloneDocumentOptions options 
)

public:  
   static Uri^ CloneDocument( 
      ObjectCache^ sourceCache, 
      ObjectCache^ targetCache, 
      Uri^ sourceDocumentUri, 
      CloneDocumentOptions^ options 
   )

def CloneDocument(self,options):

Parameters

sourceCache

The cache object containing the data for the source document. This value must not be null.

targetCache

The cache object that will contain the data for the destination document. This value must not be null and can be the same value as sourceCache to clone in the document in the same cache.

sourceDocumentUri

URI to the data of the source document in the cache. This must be in the format of an uploaded document in the cache (leadcache://documentId).

options

Options to use during cloning.

Return Value

The URL to the uploaded data of the new newly created document if successful. This value is in the leadcache://documentId format.

Remarks

This method can be used to clone the data of an uploaded document in the same or a separate cache.

This method performs the following:

Calls BeginUpload on the targetCache using DocumentId and CachePolicy of options.
Repeatedly calls DownloadDocument on sourceCache and UploadDocument on targetCache to download the document data from the source and upload it into the destination.
Repeatedly calls DownloadAnnotations on sourceCache and UploadAnnotations on targetCache to download the annotation data (if any) from the source and upload it into the destination.
Calls EndUpload on targetCache when done.
Returns the URL to the newly uploaded document in targetCache.

Use CloneDocument(ObjectCache,ObjectCache,string,CloneDocumentOptions) or CloneDocument(ObjectCache,string,CloneDocumentOptions) to clone an existing document in the same cache.

Example

This example uploads a document into the cache and then makes a clone of the data.

Java

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.Document.Writer; 
 
using Leadtools.Document; 
using Leadtools.Caching; 
using Leadtools.Annotations.Engine; 
using Leadtools.Ocr; 
using Leadtools.Barcode; 
using Leadtools.Document.Converter; 
 
 
public void FactoryCloneDocumentExample() 
{ 
   var documentUri = new Uri("https://demo.leadtools.com/images/pdf/leadtools.pdf"); 
 
   // Setup a cache 
   FileCache cache = new FileCache(); 
   cache.CacheDirectory = @"c:\cache-dir"; 
 
   string documentId1; 
   string documentId2; 
 
   // Load a document into the cache 
   var loadDocumentOptions = new LoadDocumentOptions(); 
   loadDocumentOptions.Cache = cache; 
   using (var document1 = DocumentFactory.LoadFromUri(documentUri, loadDocumentOptions)) 
   { 
      // Get its document ID and save it 
      documentId1 = document1.DocumentId; 
      document1.AutoDeleteFromCache = false; 
      document1.AutoSaveToCache = false; 
      document1.SaveToCache(); 
   } 
 
   // Clone it in the cache 
   var cloneDocumentOptions = new CloneDocumentOptions(); 
   using (var document2 = DocumentFactory.CloneDocument(cache, documentId1, cloneDocumentOptions)) 
   { 
      // Get its document ID and save it 
      documentId2 = document2.DocumentId; 
      document2.AutoDeleteFromCache = false; 
      document2.AutoSaveToCache = false; 
      document2.SaveToCache(); 
   } 
 
   // Ensure both documents are in the cache 
   DocumentCacheInfo cacheInfo; 
   cacheInfo = DocumentFactory.GetDocumentCacheInfo(cache, documentId1); 
   Debug.Assert(cacheInfo != null); 
   cacheInfo = DocumentFactory.GetDocumentCacheInfo(cache, documentId2); 
   Debug.Assert(cacheInfo != null); 
 
   // Now delete the first document 
   var deleteFromCacheOptions = new LoadFromCacheOptions(); 
   deleteFromCacheOptions.Cache = cache; 
   deleteFromCacheOptions.DocumentId = documentId1; 
   DocumentFactory.DeleteFromCache(deleteFromCacheOptions); 
   cacheInfo = DocumentFactory.GetDocumentCacheInfo(cache, documentId1); 
   Debug.Assert(cacheInfo == null); 
 
   // Or by loading it from the cache, it should be null 
   var loadFromCacheOptions = new LoadFromCacheOptions(); 
   loadFromCacheOptions.Cache = cache; 
   loadFromCacheOptions.DocumentId = documentId1; 
   using (var document1 = DocumentFactory.LoadFromCache(loadFromCacheOptions)) 
   { 
      Debug.Assert(document1 == null); 
   } 
 
   // And ensure that the cloned document is still usable by loading it 
   loadFromCacheOptions = new LoadFromCacheOptions(); 
   loadFromCacheOptions.Cache = cache; 
   loadFromCacheOptions.DocumentId = documentId2; 
   using (var document2 = DocumentFactory.LoadFromCache(loadFromCacheOptions)) 
   { 
      Debug.Assert(document2 != null); 
   } 
 
   // We are done, clean up 
   deleteFromCacheOptions = new LoadFromCacheOptions(); 
   deleteFromCacheOptions.Cache = cache; 
   deleteFromCacheOptions.DocumentId = documentId2; 
   DocumentFactory.DeleteFromCache(deleteFromCacheOptions); 
}

 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.net.MalformedURLException; 
import java.net.URI; 
import java.net.URISyntaxException; 
import java.net.URL; 
import java.nio.file.Files; 
import java.nio.file.Paths; 
import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.List; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 
import java.util.regex.Pattern; 
 
import org.junit.*; 
import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 
import static org.junit.Assert.*; 
 
import leadtools.*; 
import leadtools.annotations.engine.*; 
import leadtools.barcode.*; 
import leadtools.caching.*; 
import leadtools.codecs.*; 
import leadtools.document.*; 
import leadtools.document.DocumentMimeTypes.UserGetDocumentStatusHandler; 
import leadtools.document.converter.*; 
import leadtools.document.writer.*; 
import leadtools.ocr.*; 
 
 
public void cloneDocumentExample() throws URISyntaxException { 
   URI documentUri = new URI("https://demo.leadtools.com/images/pdf/leadtools.pdf"); 
 
   // Setup a cache 
   FileCache cache = new FileCache(); 
   cache.setCacheDirectory("c:\\cache-dir"); 
 
   String documentId1; 
   String documentId2; 
 
   // Load a document into the cache 
   LoadDocumentOptions loadDocumentOptions = new LoadDocumentOptions(); 
   loadDocumentOptions.setCache(cache); 
   LEADDocument document1 = DocumentFactory.loadFromUri(documentUri, loadDocumentOptions); 
 
   // Get its document ID and save it 
   documentId1 = document1.getDocumentId(); 
   document1.setAutoDeleteFromCache(false); 
   document1.setAutoSaveToCache(false); 
   document1.saveToCache(); 
 
   // Clone it in the cache 
   CloneDocumentOptions cloneDocumentOptions = new CloneDocumentOptions(); 
   LEADDocument document2 = DocumentFactory.cloneDocument(cache, documentId1, cloneDocumentOptions); 
 
   // Get its document ID and save it 
   documentId2 = document2.getDocumentId(); 
   document2.setAutoDeleteFromCache(false); 
   document2.setAutoSaveToCache(false); 
   document2.saveToCache(); 
 
   // Ensure both documents are in the cache 
   DocumentCacheInfo cacheInfo; 
   cacheInfo = DocumentFactory.getDocumentCacheInfo(cache, documentId1); 
   assertTrue(cacheInfo != null); 
   cacheInfo = DocumentFactory.getDocumentCacheInfo(cache, documentId2); 
   assertTrue(cacheInfo != null); 
 
   // Now delete the first document 
   LoadFromCacheOptions deleteFromCacheOptions = new LoadFromCacheOptions(); 
   deleteFromCacheOptions.setCache(cache); 
   deleteFromCacheOptions.setDocumentId(documentId1); 
   DocumentFactory.deleteFromCache(deleteFromCacheOptions); 
   cacheInfo = DocumentFactory.getDocumentCacheInfo(cache, documentId1); 
   assertTrue(cacheInfo == null); 
 
   // Or by loading it from the cache, it should be null 
   LoadFromCacheOptions loadFromCacheOptions = new LoadFromCacheOptions(); 
   loadFromCacheOptions.setCache(cache); 
   loadFromCacheOptions.setDocumentId(documentId1); 
   document1 = DocumentFactory.loadFromCache(loadFromCacheOptions); 
   assertTrue(document1 == null); 
 
   // And ensure that the cloned document is still usable by loading it 
   loadFromCacheOptions = new LoadFromCacheOptions(); 
   loadFromCacheOptions.setCache(cache); 
   loadFromCacheOptions.setDocumentId(documentId2); 
   document2 = DocumentFactory.loadFromCache(loadFromCacheOptions); 
   assertTrue(document2 != null); 
 
   // We are done, clean up 
   deleteFromCacheOptions = new LoadFromCacheOptions(); 
   deleteFromCacheOptions.setCache(cache); 
   deleteFromCacheOptions.setDocumentId(documentId2); 
   DocumentFactory.deleteFromCache(deleteFromCacheOptions); 
}

Requirements

Target Platforms

Reference

DocumentFactory Class

DocumentFactory Members

Leadtools.Document Namespace

Download our FREE evaluation

Help Version 23.0.2024.2.29

Leadtools.Document Assembly

Introduction

Getting Started

Namespaces

Leadtools.Document Namespace

Assemblies