// copyright 2021-23 BAE Systems
// copyright 2023 Real-Time Innovations
// copyright 2023 Sparx Systems Pty Ltd
// copyright 2023 SimVentions
// copyright 2023 Open Text Inc.
// copyright 2021-23 Object Management Group Inc

// Version 1.0

#ifndef ORGOMGTDAIMETAMODELDATAMODELUTILSDEFVAR
#define ORGOMGTDAIMETAMODELDATAMODELUTILSDEFVAR
#include "EntityPayload.idl"

module org
{

  module omg
  {

    module tdai
    {

      module MetaModel
      {

        module DataModel
        {

          // The Utils package in the Data Model Meta-Model defines utility classes required
          // by other Data Model and Service Model packages.
          module Utils
          {

            // A datatype with a platform specific mapping to represent a reference to a data
            // item instance.
            typedef string DataRef;

            // A general abstraction of categories to qualify an object. This class has an
            // implementation specific null value that has the meaning of no statement being
            // made in regard of the category of the descriptor.
            struct Descriptor
            {
              // Prefix for the schema from which the value is drawn
              string schemaPrefix;
              // Value from the schema denoted by the prefix
              string value;
            };

            // A string type
            // This is a datatype with a platform specific mapping to represent additional
            // information through an extension mechanism
            typedef string Detail;

            // A datatype with a platform specific mapping to represent a relative length of
            // time
            typedef unsigned long long Duration;

            // A datatype with a platform specific mapping to represent a percentage value
            typedef double Percentage;

            // A datatype with a platform specific mapping to represent a scalar quantity
            typedef double Quantity;

            // An abstraction of the categories of quantity
            struct QuantityDescriptor
            {
              // Prefix for the schema from which the value is drawn
              string schemaPrefix;
              // Value from the schema denoted by the prefix
              string value;
            };

            // A sequence type, to represent multiple values.
            typedef sequence<org::omg::tex::DataPayload::EntityPayload::ExtendedData> AdditionalDataUnstructuredData;

            // A class to represent additional, system-specific qualitative or categorical
            // values as a extension mechanism.
            struct Qualifier
            {
              // The name of quality being described
              Descriptor name;
              // The category value of the quality being described
              Descriptor value;
            };

            // A abstract mechanism to quantify capabilities and dependencies
            struct Quantifier
            {
              // The numerical value of the concept being quantified
              Quantity value;
              // An extensible categorization of the type of quantity being specified. The
              // descriptor is the determiner of the units (if any) associated with the quantity.
              QuantityDescriptor descriptor;
            };

            // A sequence type, to represent multiple values.
            typedef sequence<Qualifier> AdditionalDataQualifier;

            // A sequence type, to represent multiple values.
            typedef sequence<Quantifier> AdditionalDataQuantifier;

            // Standardized encapsulation of qualitative, quantitative and unstructured data
            // extension mechanisms.
            struct AdditionalData
            {
              AdditionalDataUnstructuredData unstructuredData;
              // A set of additional qualitative attributes as an extension mechanism.
              AdditionalDataQualifier qualifier;
              // A set of additional quantitative attributes  as an extension mechanism.
              AdditionalDataQuantifier quantifier;
            };

          };
        };
      };
    };
  };
};
#endif