Aspose.PDF for Go via C++ 25.2

Author: OleksandrAndriienko

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Aspose.PDF Product Family
+Copyright (c) 2025 Aspose Pty Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

LICENSE_COMMERCIAL.txt

@@ -0,0 +1,5 @@
+The shared library (DLL, SO, DYLIB) and its associated files are proprietary
+and are not covered under the MIT License. Detailed terms and conditions are
+specified in the Aspose EULA.
+
+You may obtain a copy of the Aspose EULA at: https://about.aspose.com/legal/eula

README.md

@@ -0,0 +1,256 @@
+# Aspose.PDF for Go via C++
+
+The package asposepdf is a powerful toolkit that allows developers to manipulate PDF files directly and helps do various tasks for PDF.
+Contains unique features for converting PDF to other formats.
+
+## Features
+
+### PDF Processing
+
+- **Core operation:** New, Open, Save, SaveAs, Close, SetLicense, WordCount, CharacterCount
+- **Page core operation:** Add, Insert, Delete, Count, WordCount, CharacterCount, IsBlank
+- **Organize:** Optimize, OptimizeResource, Grayscale, Rotate, SetBackground, Repair
+- **Page organize:** Rotate, SetSize, Grayscale, AddText
+- **Others:** Get contents as plain text
+
+### PDF converting and saving
+
+- **Microsoft Office:** DOC, DOCX, XLSX, PPTX
+- **Images:** JPEG, PNG, BMP, TIFF
+- **Others:** EPUB, DICOM, SVG, XPS, TEX, TXT
+
+## Platforms
+
+Implemented support for Linux x64, macOS x86_64, macOS arm64 and Windows x64 platforms. Used [cgo](https://go.dev/wiki/cgo).
+
+The platform-specific version of the dynamic library from the 'lib'-folder in the package's root directory is required for distributing the resulting application:
+- *libAsposePDFforGo_linux_amd64.so* for Linux x64 platform
+- *libAsposePDFforGo_darwin_arm64.dylib* for macOS arm64 platform
+- *libAsposePDFforGo_darwin_amd64.dylib* for macOS x86_64 platform
+- *AsposePDFforGo_windows_amd64.dll* for Windows x64 platform.
+
+Windows x64 platform requires [MinGW-W64](https://www.mingw-w64.org/) installed.
+
+## Installation
+
+This package includes a large file which is stored as a bzip2 archive.
+
+1. Add the asposepdf package to Your Project:
+    ```sh
+    go get github.com/aspose-pdf/aspose-pdf-go-cpp@latest
+    ```
+
+2. Generate the large file:
+
+ - **macOS and linux**
+
+  1. Open Terminal
+
+  2. List the folders of the github.com/aspose-pdf within the Go module cache:
+
+        ```sh
+        ls $(go env GOMODCACHE)/github.com/aspose-pdf/
+        ```
+
+  3. Change curent folder to the specific version folder of the package obtained in the previous step:
+
+      ```sh
+      cd $(go env GOMODCACHE)/github.com/aspose-pdf/[email protected]
+      ```
+      Replace `@vx.x.x` with the actual package version.
+
+
+  4. Run go generate with superuser privileges:
+
+      ```sh
+      sudo go generate
+      ```
+
+ - **Windows**
+
+  1. Open Command Prompt
+  
+  2. List the folders of the github.com/aspose-pdf within the Go module cache:
+
+      ```cmd
+      for /f "delims=" %G in ('go env GOMODCACHE') do for /d %a in ("%G\github.com\aspose-pdf\*") do echo %~fa
+      ```
+
+  3. Change curent folder to the specific version folder of the package obtained in the previous step:
+
+      ```cmd
+      cd <specific version folder of the package>
+      ```
+
+  4. Run go generate:
+
+      ```cmd
+      go generate
+      ```
+
+  5. Add specific version folder of the package to the %PATH% environment variable:
+
+      ```cmd
+      setx PATH "%PATH%;<specific version folder of the package>\lib\"
+      ```
+      Replace `<specific version folder of the package>` with the actual path obtained from step 2.
+
+
+## Quick Start
+All code snippets are contained in the [snippet](https://github.com/aspose-pdf/aspose-pdf-go-cpp).
+
+### Hello World!
+
+```go
+package main
+
+import "github.com/aspose-pdf/aspose-pdf-go-cpp"
+import "log"
+
+func main() {
+	// Create new PDF-document
+	pdf, err := asposepdf.New()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Add new page
+	err = pdf.PageAdd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Set page size A4
+	err = pdf.PageSetSize(1, asposepdf.PageSizeA4)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Add text on first page
+	err = pdf.PageAddText(1, "Hello World!")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Save PDF-document with "hello.pdf" name
+	err = pdf.SaveAs("hello.pdf")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Release allocated resources
+	defer pdf.Close()
+}
+```
+
+### Save PDF as Office Formats
+
+One of the most popular features of Aspose.PDF for Go via C++ is to convert PDF documents to other formats without needing to understand the underlying structure of the resultant format.
+
+Give the following snippet a try with your samples:
+
+```go
+package main
+
+import "github.com/aspose-pdf/aspose-pdf-go-cpp"
+import "log"
+
+func main() {
+	// Open(filename string) opens a PDF-document with filename
+	pdf, err := asposepdf.Open("sample.pdf")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// SaveDocX(filename string) saves previously opened PDF-document as DocX-document with filename
+	err = pdf.SaveDocX("sample.docx")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Close() releases allocated resources for PDF-document
+	defer pdf.Close()
+}
+```
+### Extract Text From Whole PDF
+
+```go
+package main
+
+import "github.com/aspose-pdf/aspose-pdf-go-cpp"
+import "log"
+import "fmt"
+
+func main() {
+	// Open(filename string) opens a PDF-document with filename
+	pdf, err := asposepdf.Open("sample.pdf")
+	if err != nil {
+		log.Fatal(err)
+
+	}
+	// ExtractText() returns PDF-document contents as plain text
+	txt, err := pdf.ExtractText()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Print
+	fmt.Println("Extracted text:\n", txt)
+	// Close() releases allocated resources for PDF-document
+	defer pdf.Close()
+}
+```
+
+## Testing
+
+The test run from the root package folder:
+
+```sh
+go test -v
+```
+
+## License
+
+- The **Go source code** is licensed under the [MIT License](LICENSE).
+- The **shared library (`AsposePDFforGo_windows_amd64.dll`, `libAsposePDFforGo_linux_amd64.so`, `libAsposePDFforGo_darwin_amd64.dylib`, `libAsposePDFforGo_darwin_arm64.dylib`)** is proprietary and requires a commercial license.
+  To use the full functionality, you must obtain a license.
+
+### Evaluation version
+
+You can use Aspose.PDF for Go via C++ free of cost for evaluation.The evaluation version provides almost all functionality of the product with certain limitations. The same evaluation version becomes licensed when you purchase a license and add a couple of lines of code to apply the license.
+
+>If you want to test Aspose.PDF for Go without the evaluation version limitations, you can also request a 30-day Temporary License. Please refer to [How to get a Temporary License?](https://purchase.aspose.com/temporary-license)
+
+### Limitation of an evaluation version
+
+We want our customers to test our components thoroughly before buying so the evaluation version allows you to use it as you would normally.
+
+- **Documents created with an evaluation watermark.** The evaluation version of Aspose.PDF for Go provides full product functionality, but all pages in the generated files are watermarked with the text "Evaluation Only. Created with Aspose.PDF. Copyright 2002-2025 Aspose Pty Ltd." at the top.
+- **Limit the number of pages that can be processed.** In the evaluation version, you can only process the first four pages of a document.
+
+### Use in production
+
+A commercial license key is required in a production environment. Please contact us to <a href="https://purchase.aspose.com/buy">purchase a commercial license</a>.
+
+### Apply license
+
+Applying a license to enable full functionality of the Aspose.PDF for Go using a license file (Aspose.PDF.GoViaCPP.lic).
+
+```go
+
+    package main
+
+    import "github.com/aspose-pdf/aspose-pdf-go-cpp"
+    import "log"
+
+    func main() {
+        // Open(filename string) opens a PDF-document with filename
+        pdf, err := asposepdf.Open("sample.pdf")
+        if err != nil {
+            log.Fatal(err)
+        }
+        // SetLicense(filename string) licenses with filename
+        err = pdf.SetLicense("Aspose.PDF.GoViaCPP.lic")
+        if err != nil {
+            log.Fatal(err)
+        }
+        // Working with PDF-document
+        // ...
+        // Close() releases allocated resources for PDF-document
+        defer pdf.Close()
+    }
+```
+
+[Home](https://www.aspose.com/) | [Product Page](https://products.aspose.com/pdf/go-cpp/) | [Docs](https://docs.aspose.com/pdf/go-cpp/) | [Demos](https://products.aspose.app/pdf/family) | [API Reference](https://reference.aspose.com/pdf/go-cpp/) | [Examples](https://github.com/aspose-pdf/aspose-pdf-go-cpp/) | [Blog](https://blog.aspose.com/category/pdf/) | [Search](https://search.aspose.com/) | [Free Support](https://forum.aspose.com/c/pdf) |  [Temporary License](https://purchase.aspose.com/temporary-license)

asposepdf_test.go

@@ -0,0 +1,119 @@
+// use:
+// go test -v
+
+package asposepdf
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func assert_check_types(t *testing.T, left any, right any) {
+	if reflect.TypeOf(left) != reflect.TypeOf(right) {
+		t.Fatalf("Different types: %v (type %v) and %v (type %v)", left, reflect.TypeOf(left), right, reflect.TypeOf(right))
+	}
+}
+
+func assert_eq(t *testing.T, left any, right any) {
+	assert_check_types(t, left, right)
+	if !reflect.DeepEqual(left, right) {
+		t.Errorf("%v != %v", left, right)
+	}
+}
+
+func assert_ne(t *testing.T, left any, right any) {
+	assert_check_types(t, left, right)
+	if reflect.DeepEqual(left, right) {
+		t.Errorf("%v == %v", left, right)
+	}
+}
+
+func TestNewAndSave(t *testing.T) {
+
+	pdf_new_filename := fmt.Sprintf("%s/new.pdf", t.TempDir())
+
+	pdf_new, err := New()
+	if err != nil {
+		t.Errorf("New(): %v", err)
+	} else {
+		err = pdf_new.SaveAs(pdf_new_filename)
+		if err != nil {
+			t.Errorf("SaveAs(%s): %v", pdf_new_filename, err)
+		} else {
+			pdf_empty, err := Open(pdf_new_filename)
+			if err != nil {
+				t.Errorf("Open(%s): %v", pdf_new_filename, err)
+			} else {
+				err = pdf_empty.Save()
+				if err != nil {
+					t.Errorf("Save(%s): %v", pdf_new_filename, err)
+				}
+			}
+			defer pdf_empty.Close()
+		}
+	}
+	defer pdf_new.Close()
+
+	// Check file size != 0
+	fi, err := os.Stat(pdf_new_filename)
+	if err != nil {
+		t.Errorf("Stat(%s): %v", pdf_new_filename, err)
+	}
+	assert_ne(t, int64(0), fi.Size())
+}
+
+func TestPages(t *testing.T) {
+
+	pdf, _ := New()
+	defer pdf.Close()
+
+	// Add page
+	_ = pdf.PageAdd()
+	// Set page size
+	_ = pdf.PageSetSize(1, PageSizeA1)
+	// Insert page at first position
+	_ = pdf.PageInsert(1)
+	// Delete first page
+	_ = pdf.PageDelete(1)
+	// Gets number of pages
+	page_count, _ := pdf.PageCount()
+	// The number of pages must be equal to 1
+	assert_eq(t, page_count, int32(1))
+}
+
+func TestStats(t *testing.T) {
+
+	pdf, _ := New()
+	defer pdf.Close()
+
+	// Text with stamp: "Evaluation Only. Created with Aspose.PDF ..."
+
+	// Add page
+	_ = pdf.PageAdd()
+	// Save
+	_ = pdf.SaveAs(fmt.Sprintf("%s/stat.pdf", t.TempDir()))
+
+	// Word count
+	word_count, _ := pdf.WordCount()
+	// The number of word count must be equal to 12
+	assert_eq(t, word_count, int32(12))
+	// Character count
+	character_count, _ := pdf.CharacterCount()
+	// The number of character count must be equal to 74
+	assert_eq(t, character_count, int32(74))
+
+	// Word count on first page
+	page_word_count, _ := pdf.PageWordCount(1)
+	// The number of word count must be equal to 12
+	assert_eq(t, page_word_count, int32(12))
+	// Character count on first page
+	page_character_count, _ := pdf.PageCharacterCount(1)
+	// The number of character count must be equal to 74
+	assert_eq(t, page_character_count, int32(74))
+
+	// First page is blank? No. Evaluation stamp
+	page_is_blank, _ := pdf.PageIsBlank(1)
+	assert_eq(t, page_is_blank, false)
+}