ProcessMIX Guide
  • Platform Overview
    • Introduction
    • Platform Purpose
    • Main Concepts
      • Organization Structure
      • Visual Language
      • Project Development Environment (IDE)
      • Deployment and Integration
      • Administration and Troubleshooting
    • First Steps
    • Change Log
      • 5.0.0
      • 5.0.5
      • 5.0.5.1
      • 5.0.5.2
      • 5.0.5.3
      • 5.0.5.4
  • Language Reference Guide
    • Overview
    • Data Structures and Types
      • Core Types (pdk.core)
      • Dictionary (pdk.asset.dictionary)
      • Scorecard (pdk.asset.scorecard)
      • Blockchain (pdk.blockchain)
      • Exceptions (pdk.ex)
      • Input/Output (pdk.io)
      • JSON Web Token (pdk.jwt)
      • Networking (pdk.net)
      • HTTP (pdk.net.http)
      • SOAP/Web Services (pdk.net.soap)
      • XML/DOM (pdk.net.xml)
      • S3 (pdk.s3)
      • SQL (pdk.sql)
      • Postgres (pdk.db.postgre)
      • Util (pdk.util)
      • Default Data Structure Field Values
    • Flows
      • Variables
        • Local Flow Variables
        • Node Variables
      • Flow Node Types
        • Core Nodes
          • In
          • Out
          • Assign
          • If
          • Switch
          • Iterator
          • Function Call
          • Subflow
          • Raise Exception
          • Exception Handler
          • Validator
        • Connector Nodes
          • Database Begin Transaction
          • Database Commit Transaction
          • Database Rollback Transaction
          • Database Query Executor
          • EVM Blockchain Functions
          • EVM Blockchain Smart Contract Functions
          • REST Service Executor
          • SOAP Service Executor
          • S3 Connector
          • SMB Connector
      • Expressions
      • Built-In Functions
        • Expression functions
          • pdk.util.Any
          • pdk.util.Array
          • pdk.util.Blockchain
          • pdk.util.Cast
          • pdk.util.Codec
          • pdk.util.Crypto
          • pdk.util.Date
          • pdk.util.File
          • pdk.util.Json
          • pdk.util.JWT
          • pdk.util.Map
          • pdk.util.Math
          • pdk.util.String
          • pdk.util.Util
        • Node functions
          • pdk.flow.Any
          • pdk.flow.Array
          • pdk.flow.File
          • pdk.flow.JsonArray
          • pdk.flow.JsonObject
          • pdk.flow.HttpRequest
          • pdk.flow.HttpResponse
          • pdk.flow.Logger
          • pdk.flow.Map
          • pdk.flow.Xml
            • pdk.flow.xml.XmlAttr
            • pdk.flow.xml.XmlElement
            • pdk.flow.xml.XmlNode
            • pdk.flow.xml.XmlDocument
            • pdk.flow.xml.XmlDocumentType
            • pdk.flow.xml.XmlDOMConfiguration
            • pdk.flow.xml.XmlDOMImplementation
            • pdk.flow.xml.XmlProcessingInstruction
            • pdk.flow.xml.XmlTypeInfo
            • pdk.flow.xml.XmlCharacterData
            • pdk.flow.xml.XmlText
            • pdk.flow.xml.XmlNamedNodeMap
          • pdk.node.BlockchainEth
          • pdk.node.S3
          • pdk.node.Smb
      • Exceptions
        • Checked Exceptions
        • Runtime Exceptions
    • Assets
      • Dictionary
      • Decision Table
      • Scorecard
      • PMML
    • Connectors
      • DB Connector
        • Prepared Query
        • Dynamic Query
        • Query input parameters
        • Stored Procedure
      • REST Connector
      • SOAP Connector
      • S3 Connector
      • SMB Connector
      • EVM Blockchain Connector
    • Global Variables
    • Appendices
      • Overview of Database Transactions
      • Reserved Words
  • Project Development Environment (IDE)
    • Project Explorer Panel
    • Flow Builder
    • Flow Node Editor
    • Data Structure Builder
    • Connector Builders
      • REST Connector Builder
      • SOAP Connector Builder
      • DB (Database) Connector Builder
      • EVM Blockchain Connectors Builder
      • S3 Connector Builder
    • Asset Builders
      • Dictionary Builder
      • Decision Table Builder
      • Scorecard Builder
      • PMML Asset Builder
    • Global Variables Panel
    • Expression Editor
    • Project Deployment and Execution
    • Cron Expression Generator
    • Test Helper
    • Debugging the Project
    • DB transactions
    • Team Collaboration Tools
      • Version Control
      • Conflict Resolver
    • Selectors
    • Error Panel
    • Local History
  • Home and Administration Guide
    • Organization and Subscription
    • Organization Team
    • Repositories and Projects
    • Environments
    • Deployments
    • Database Provisioning
    • Roles and Permissions
  • Logs and Troubleshooting
    • Request/Call Logs
    • Deployment Logs
    • Application Logs
  • Appendix: Example Project
    • Risk Mitigation Solution
Powered by GitBook
On this page
  • Any
  • Object
  • UserObject
  • Number
  • Integer
  • Float
  • String
  • Boolean
  • Date
  • Byte
  • Array
  • Map
  • MapEntry
  1. Language Reference Guide
  2. Data Structures and Types

Core Types (pdk.core)

Contains core data structure definitions

PreviousData Structures and TypesNextDictionary (pdk.asset.dictionary)

Last updated 7 months ago

Any

A root type from which all other data types and structures are derived.

Superstructures: none


Object

A superstructure for all non-primitive structures (i.e. those not used to describe simple data types).

A primitive data structure (simple type) cannot contain any other properties, only its own value.

Superstructures:


UserObject

A base structure from which all user-defined data structures are derived.

Superstructures: <-


Number

A superstructure for all numeric data types.

Superstructures:


Integer

Represents whole numbers and to store numeric values without fractional or decimal parts. These values can be both positive and negative.


Float

Represents real numbers - numbers that can contain a fractional component (have a decimal point) . It is used to store both positive and negative real numbers with arbitrary precision.


String

Represents a sequence of characters, typically intended to store and manipulate text. A string can contain any letters, numbers, symbols, and whitespace characters.


Boolean

Represents a simple binary/logical value that can be either true or false.


Date

Represents a specific moment in date and time with millisecond precision.

The Date structure is intended to reflect coordinated universal time (UTC). Nearly all modern operating systems assume that 1 day = 24 × 60 × 60 = 86400 seconds in all cases. In UTC, however, about once every year or two there is an extra second, called a "leap second".

In all platform functions using Date type that accept or return year, month, date, hours, minutes, and seconds values, the following representations are used:

  • A year y is represented by the integer y - 1900.

  • A month is represented by an integer from 0 to 11; 0 is January, 1 is February, and so forth; thus 11 is December.

  • A date (day of month) is represented by an integer from 1 to 31 in the usual manner.

  • An hour is represented by an integer from 0 to 23. Thus, the hour from midnight to 1 a.m. is hour 0, and the hour from noon to 1 p.m. is hour 12.

  • A minute is represented by an integer from 0 to 59 in the usual manner.

  • A second is represented by an integer from 0 to 61; the values 60 and 61 occur only for leap seconds. Because of the manner in which leap seconds are currently introduced, it is extremely unlikely that two leap seconds will occur in the same minute, but this specification follows the date and time conventions for ISO C.

In all cases, arguments given to methods for these purposes need not fall within the indicated ranges; for example, a date may be specified as January 32 and is interpreted as meaning February 1.


Byte


Array

A data structure that stores a collection of items, such as a sequence of elements, of the same type. Each element in an array can be accessed by its index, which starts with 0 (i.e. the first element in an array is referenced by an index of 0).

Example:

numbers : Array<String>
numbers = ['A', 'B', 'C']

index of 'A' = 0
index of 'B' = 1
index of 'C' = 2

Example of parameterization:

Animal extends UserObject
Tiger extends Animal
Capybara extends Animal

Zoo extends UserObject
    allAnimals:  Array<Animal>
    tigers:  Array<Tiger>

In the above example, allAnimals array can hold both Tiger and Capybara elements, while tigers can hold only Tiger.


Map

A structure that maps string keys to values so that each value can be looked up by its unique key. A map cannot contain duplicate keys: each key can map to at most one value.

Here is an example in a pseudo-language to demonstrate its use:

orders: Map<Order> = {} // empty map

// Populate new book order structure instance
bookOrder: Order = {
    "id": 1,
    "price": 10.99,
    "count": 5
}

// Call Map.put() function to add a new map entry
Map.put(orders, "1", bookOrder)

// Resulting map
orders = {
    "1": {
        "id": 1,
        "price": 10.99,
        "count": 5
    }
}

MapEntry

Properties:

  • value :: <Type>

    parameterized element type

Superstructures: <-

Superstructures: <-

Superstructures: <-

Superstructures:

Superstructures:

Represents an 8-bit signed integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte structure can be useful sometimes to save memory occupied by very large .

Superstructures:

Array is a type. It means that the type of the array's elements must be explicitly chosen in a property with Array type is defined.

Superstructures: <-

Keys in the map can only be of type

Map is a type.

Superstructures: <-

A single entry (key-value pair) in the data structure.

MapEntry is a type.

key ::

Any
Object
Any
Any
Number
Any
Number
Any
Object
Any
Any
Any
arrays
Any
parameterized
Object
Any
pdk.core.String
parameterized
Object
Any
pdk.core.Map
parameterized
pdk.core.String