Cross platform object serialization, network, and design patterns
The Communications Toolkit consists of Standards Toolkit plus six class libraries. You can install and use any combination of these libraries independently from another provided you have a version of the ANSI/ISO C++ Standard Library:
- Streaming Toolkit™ Library – A high-performance implementation of the Universal Streaming Service. The only non-intrusive solution for persisting objects across heterogeneous networks!
- Network Toolkit™ Library – A complete set of object-oriented classes for TCP/IP-based socket programming. Also includes portable interfaces for network information services and I/O multiplexing.
- Pipe Toolkit™ Library – A portable interface for pipe communication, a popular protocol on Microsoft Windows-based operating systems.
- File Toolkit™ Library – The most complete class library for platform-independent manipulation of files, paths, directories, and record locks.
- Security Toolkit™ Library – A set of object-oriented classes for manipulating users and groups.
- IO Toolkit™ Library – A collection of common I/O-related classes that are used by other Recursion Software components.
- Framework Toolkit™ Library – A collection of common design pattern implementations that are used as the framework for which to build robust, scalable applications.
Streaming Toolkit™ Library
Streaming Toolkit is a complete implementation of the Universal Streaming Service, a non-intrusive mechanism for facilitating platform‚ independent object persistence and network transport of objects. Unlike many proprietary solutions, Streaming Toolkit does not require invasive modifications to class definitions or alterations to inheritance structures. This library is designed for use with your own objects, other vendors’ objects, or any STL container. It is the only serialization mechanism available today with complete C++ advanced language feature support, including full serialization of advanced templates.
Streaming Toolkit contains a set of classes that provide:
- Object persistence and transport – Easily store and retrieve objects to and from files, as well as send objects across TCP sockets or other devices to another computer.
- IOStream device interfaces – Use familiar text-streaming interfaces and manipulators on a variety of I/O devices, such as TCP sockets.
Streaming Toolkit was carefully designed to provide the following benefits:
- Ease of Use – All stream interfaces in Streaming Toolkit are based on well-known semantics using operator>> and operator<<.
- Non-intrusive Design – Streaming Toolkit is designed to provide object persistence and transport without requiring class modifications. Using Streaming Toolkit requires no inheritance and, in most cases, requires no code changes at all.
- Full Language Support – Streaming Toolkit fully supports all advanced language features including templates, multiple inheritance, and virtual base classes.
- Cross-platform Support – Streaming Toolkit uses the Network Data Representation (NDR) protocol by default to ensure data is portable between different operating systems. Issues such as byte ordering or data size are correctly managed.
- Protocol Independence – The powerful layered architecture in Streaming Toolkit allows users to easily change protocols. In addition to NDR, native and ASCII protocols are provided; users can easily extend this to include their own variants.
- Vendor Neutrality – Due to its non-intrusive design, Streaming Toolkit can stream any of your own objects, any standard library container or string, and any of several third-party vendor objects with the same mechanism.
- Device Independence – The Streaming Toolkit architecture allows easy adaptation to support any number of devices. All Recursion Software devices are automatically supported, including files, pipes, and sockets. Customers have readily adapted Streaming Toolkit to OLE and a variety of other transport mechanisms.
Network Toolkit™ Library
Network Toolkit is a complete, cross-platform C++ encapsulation of TCP and UDP socket programming interfaces. Sockets are bi-directional communication mechanisms providing communication between processes, even if they are on different machines. Designed for distributed applications, Network Toolkit provides all the mechanisms necessary for creating robust, high-performance systems:
- TCP sockets – Reliable, connection-based transport typically used in distributed or Internet-based applications.
- UDP sockets – Efficient, packet-based transport commonly used in real-time and broadcast-oriented applications.
- I/O multiplexing – Sophisticated socket manager that manages multiple sockets simultaneously by selecting the socket that needs attention.
- Information interfaces – Information retrieval from accessible hosts, services, and networks.
Network Toolkit was carefully designed to provide the following important benefits:
- Availability – With the rapid growth of the Internet, the Internet Protocol is one of the fastest growing, generally available transport protocols in existence. This makes Network Toolkit a generally available solution for network programming today and long into the future.
- Ease of Use – Socket programming using C interfaces is difficult to learn and use safely. Network Toolkit provides a C++ hierarchy that makes creating and using TCP and UDP sockets simple and intuitive.
- Comprehensive Interfaces – Network Toolkit interfaces provide simplicity for common use, but not at the expense of low level control. Network Toolkit provides access to all the underlying socket control parameters and allows for late binding. Full database interfaces for host, network, and service data are provided.
- Portable Object Transport, with Streaming Toolkit – Combining the Streaming Toolkit with Network Toolkit allows portable object transport between machines and intuitive IOStream interfaces to sockets.
Pipe Toolkit™ Library
Pipe Toolkit provides a portable interface for pipe communications. These object-oriented interfaces are designed to allow developers to upgrade to TCP/IP-based protocols with minimal code modifications:
- Client – Connects to named pipe services for transaction processing.
- Server – Establishes a named pipe service and accepts connection requests.
Pipe Toolkit offers the following benefits to programmers:
- Portability – Though pipes behave somewhat differently among operating systems, Pipe Toolkit brings together the common behaviors in a way that allows portable source code development for pipe-based communications.
- Consistency – For pipe programmers, a consistent C++ interface makes programs easy to understand and maintain.
- Simplicity – Creating and connecting to pipes using Pipe Toolkit is easy and intuitive.
- Streaming Toolkit – When used in conjunction with Streaming Toolkit, programmers can use textual IOStream interfaces for pipe communication, as well as binary object transport across pipes.
File Toolkit™ Library
File Toolkit provides a portable interface to paths, files, and directories. Problems such as manipulating path names in C++ using strings or accessing a list of files in a directory are simplified with these intuitive C++ interfaces:
- Paths and files – Cross-platform file and directory path representation and a complete portable encapsulation of a file’s interface.
- File lock – Interfaces for locking all or part of a file for protection.
- Directory – A cross-platform C++ interface to directories and folders.
File Toolkit offers the following benefits to programmers:
- Portability – File Toolkit provides completely portable interfaces. These interfaces address the inconsistent implementation of path names, file handles, file locking, and the creation and use of directories across operating systems.
- Simplicity – Problems such as manipulating path names in C++, accessing a list of files in a directory, or simply determining if a file exists are simplified with the intuitive C++ interfaces found in File Toolkit.
Security Toolkit™ Library
Security Toolkit provides the ability to manipulate users and groups in an object-oriented way, since most entities, such as files and IPC mechanisms, are owned by a particular user and have an associated group:
IO Toolkit Library
IO Toolkit is a collection of common I/O-related classes that are used by other Recursion Software components, including File Toolkit, Network Toolkit, Pipe Toolkit, Streaming Toolkit, Security Toolkit, and Unix Toolkit for UNIX. The functionality provided by IO Toolkit can be classified into the following sections:
- Device Adapters – Lightweight mechanisms that provide a uniform interface for manipulating and communicating with I/O devices.
- Device Cache – A specialized device adapter that provides read/write caching capabilities to other device adapters.
- Common I/O Behaviors – Mechanism to access/modify the behavior of I/O devices.
Framework Toolkit™ Library
Framework Toolkit is a collection of common design pattern implementations that are used as the framework for which to build robust, scalable applications. The functionality provided by Framework Toolkit can be classified into the following sections:
- Singleton – Templatized Singleton pattern that adorns other objects, without requiring modification to the original class.
- Observer – Templatized pattern class that decouples the responsibility of an object to send change notification to its dependents and to update them automatically.
- Execution Concurrency Strategies – Patterns that define a concurrency policy for executing a runnable object. Three types of strategies are provided and include the same thread execution, new thread execution, and thread pool execution concurrency strategy.
- Acceptor/Connector – Patterns that decouple the responsibility of connection establishment and service initialization in a network application from the processing that the application is designed to perform.
- Dispatcher – Pattern that provides a framework for demultiplexing events and dispatching the appropriate service handlers.
Cross platform multi-threading
The Foundations Toolkit consists of three class libraries: Thread, Helper, and Time. You can install and use any combination of these three libraries independent from one another provided you have some version of the ANSI/ISO C++ Standard Library.
- Thread Library – A C++ class library for writing portable, multi-threaded applications. Supports advanced synchronization concepts, including critical sections, semaphores, barriers, monitors, and automatic change-notifying sentinels.
- Helper Library – Non-intrusive generic extensions to the Standard C++ Library, including generic regular expression algorithms, STL helper functions, and substring support.
- Time Library – A set of 64-bit time and date classes that support dates up to A.D. 32,766 and model time, date, time period, time zone and stopwatch.
Cross platform distributed access to ODBC databases
The C++ Database Toolkit is a full object-oriented, cross-platform C++ Class Library solution for programmatic access to a wide range of ODBC-compliant databases.
- Reduces the need to have multiple ODBC drivers for different databases installed on the client machines.
- Reduces software configuration complexity because you are only required to configure and maintain your ODBC drivers in one location at the server.
- Easy to understand C++ API that abstracts away low-level complexity, allowing for fast project ramp-up.
- Powerful built-in C++ streaming capabilities that allow client/server interaction across multiple platforms, without the need for any vendor specific code on the client side.
The C++ Database Toolkit is comprised of a client and server. The server makes use of the native operating system’s ODBC environment to respond to the requests of various database clients. The client exposes APIs to database applications that are then portable to a wide variety of platforms.
Cross platform high performance STL implementation
STL Toolkit is a portable, high-performance implementation of the most useful portions of the ANSI/ISO Standard C++ Library. The STL Toolkit offers the following:
- Containers – Generalized classes used to hold collections of typed objects
- Iterators – Generalized pointers used to traverse the elements of a container
- Algorithms – Procedures that can be applied to all or part of a container
- Allocators – Specialized objects that allocate and manage storage
- String – A complete implementation of the ANSI/ISO string specification
- Exceptions – The ANSI/ISO standard exception hierarchy.
Cross platform collections that complement and enhance the STL
ETL Toolkit contains a unique set of collections packaged to enhance the STL. It includes Sorted Vector, Dynamic Array, Hash Table, Heap as well as List, Stack, Queue, and Set structures.
- Sorted Vector – A dynamic array that automatically sorts itself so access is done via fast binary search with lowest access time
- Dynamic Array – Allows writing numeric array operations without loops via operator overloading, simplifying coding by reducing code size
- Hash Table – A complete hash table which comes with its own iterator
- Heap – Fast, full-featured implementation of the priority queue abstract data structure which utilizes dynamic arrays
- List, Stack, Queue, Set – These structures are implemented using a singly-linked circular list, which provides a constant time for insert/ removal operations at both ends of the list.
Cross platform support for web page structure and authoring
The Web Toolkit is an ANSI/ISO-compatible C++ library that contains classes for dynamically building HTML (Hypertext Markup Language) Web pages. Using Web, you can write Web page logic and structure using C++ objects and existing C++ interfaces without learning HTML. If you do not use a tool like Web when creating an application that builds Web pages, you must manually insert HTML into your code. This is not only cumbersome and error prone, but requires that you learn HTML syntax.
Web Toolkit was carefully designed to provide the following important benefits:
- Reuse – Using Web Toolkit, you can write CGI programs in C++. This allows reuse of all existing C++ libraries and interfaces. Using Web also eliminates the need to wrap existing interfaces to implement CGI programs in a scripting language.
- Simplicity – Using Web Toolkit, there is no need to worry about special characters in HTML text or in form data. There also is no need to learn any of the HTML syntax, including cumbersome start and end tag rules. Web Toolkit reduces common mistakes and allows you to focus on the tasks, rather than the tools.
- Maintenance – Using Web, programmers can use familiar object-oriented techniques, such as encapsulation, to manage large and complex CGI programs. This feature reduces the cost of extending and modifying CGI programs. Without Web, HTML must be embedded in scripts that have few facilities for managing complexity.
- Error Detection – With constraints enabled, Web provides helpful diagnostic output to troubleshoot invalid Web page composition.
Cross platform high performance scientific computing solutions
Our Math Toolkit classes are:
- Complex number – Representation of the real value and imaginary value of a complex number.
- Numeric vector – Class providing the capability to represent and manipulate numerical vectors. Operations supported include additional, subtraction, multiplication, division, indexing and others.
- Numeric matrix – Class providing the capability to represent and manipulate numerical matrixes. Operations supported include additional, subtraction, multiplication, division, indexing and others.
- Numeric array – Class providing the capability to represent and manipulate numerical arrays. Operations supported include additional, subtraction, multiplication, division, indexing and others.
- LU factorization – Compute the lower and upper triangular matrix for a given matrix.
- Fast Fourier Tranforms – Mechanisms for computing Discrete Fourier Transform.
- Random number generators – Mechanisms for computing random number based on various probability distributions.
- Least squares approximation – Compute the best-fit curve for a set of data.
- Histogram – Class providing the capability to represent and manipulate data in histograms.
Math Toolkit was carefully designed to provide the following important benefits:
- Efficiency – The interfaces in Math Toolkit are designed to provide cross-platform power without incurring high overhead. Each class is customized with minimal overhead, creating a high-performance numerical library.
- Portability – Math Toolkit uses standard C++ syntax, therefore it is portable across numerous platforms.
- Simplicity – The classes and algorithms contained in Math Toolkit are quite easy to learn and simple to use, reducing the time taken to develop mathematical applications. In fact, some examples can be used as is for mathematical analysis.
C++ Toolkit for Texas Instruments Digital Signal Processors
This product is for C++ programmers developing DSP/BIOS-based applications for Texas Instruments Da Vinci™ Digital Media Processors, and the TMS320C6000™ family of Fixed-Point and Fixed/Floating-Point Digital Signal Processors. It provides an extensive set of supplemental code libraries, sample programs and documentation that significantly extend the capabilities of the TI Code Composer Studio and Networking SDK software development tools, enabling faster development of richer and more reliable applications.
The DSP Toolkit includes the following libraries:
- A high-performance implementation of the C++ Standard Template Library
- An Extended Template Library of classes for advanced data structures
- Hash Table
- Sorted Vector
- Dynamic Array
- Circular List
- Foundation classes for various programming tasks
- Process threading
- Time and Date Functions
- STL Helper Classes
- Regular Expressions
- String Handling
- Communication classes
- Object Serialization
- Mathematics library of classes, algorithms and templates
- Complex Numbers
- Numeric Vectors
- N-Dimensional Arrays
- LU Factorization
- Fast Fourier Transforms
- Random Number Generators
- Least Squares Approximation
The hundreds of classes, templates, algorithms and other elements in the libraries are supported by more than 500 sample programs and nearly 2000 pages of documentation. And, the toolkit also includes complete C++ source code for everything in the package, which enables the programmer to modify and further optimize the supplied classes as needed for the system or application design, and for easy cross-compilation each target processor.
When used in conjunction with Code Composer Studio, the Network Development SDK and the software and hardware simulation and emulation technologies that make up the TI software development environment, the Recursion C++ Toolkit brings several significant benefits to DSP programmers:
- Optimized version of Standard Template Library enhance program performance
- Pre-built low-level classes and templates eliminate grunt work and reinvention
- Foundation Helper classes prevent design errors and STL class misuse
- Device, file and network communications classes ease testing and integration
- Extensive mathematics classes speeds development of complex applications
The Recursion Software DSP C++ Toolkit will add significant value to the full complement of application types targeted by Texas Instruments Da Vinci and C6000 processors, including machine vision, digital media, telephony, network control, speech recognition, biometrics and others. The processors supported by this product include:
- Da Vinci™ Digital Media Processors
- C6000™ High Performance DSPs
- C6000™ Performance Value DSPs
- C6000™ Floating-point DSPs