"""Support for simplified access to data on nodes of type omni.syntheticdata.SdPostInstanceMapping

Synthetic Data node to compute and store scene instances semantic hierarchy information
"""


import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn



class OgnSdPostInstanceMappingDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.syntheticdata.SdPostInstanceMapping

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.exec
            inputs.gpu
            inputs.rp
            inputs.semanticFilterName
        Outputs:
            outputs.exec
            outputs.instanceMapSDCudaPtr
            outputs.instanceMappingInfoSDPtr
            outputs.instancePrimTokenSDCudaPtr
            outputs.lastUpdateTimeDenominator
            outputs.lastUpdateTimeNumerator
            outputs.semanticLabelTokenSDCudaPtr
            outputs.semanticLocalTransformSDCudaPtr
            outputs.semanticMapSDCudaPtr
            outputs.semanticPrimTokenSDCudaPtr
            outputs.semanticWorldTransformSDCudaPtr

    Predefined Tokens:
        tokens.InstanceMappingInfoSDhost
        tokens.SemanticMapSD
        tokens.SemanticMapSDhost
        tokens.SemanticPrimTokenSD
        tokens.SemanticPrimTokenSDhost
        tokens.InstanceMapSD
        tokens.InstanceMapSDhost
        tokens.InstancePrimTokenSD
        tokens.InstancePrimTokenSDhost
        tokens.SemanticLabelTokenSD
        tokens.SemanticLabelTokenSDhost
        tokens.SemanticLocalTransformSD
        tokens.SemanticLocalTransformSDhost
        tokens.SemanticWorldTransformSD
        tokens.SemanticWorldTransformSDhost
    """

    # Imprint the generator and target ABI versions in the file for JIT generation
    GENERATOR_VERSION = (1, 41, 3)
    TARGET_VERSION = (2, 139, 12)

    # This is an internal object that provides per-class storage of a per-node data dictionary
    PER_NODE_DATA = {}

    # This is an internal object that describes unchanging attributes in a generic way
    # The values in this list are in no particular order, as a per-attribute tuple
    #     Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
    #     Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
    # You should not need to access any of this data directly, use the defined database interfaces
    INTERFACE = og.Database._get_interface([
        ('inputs:exec', 'execution', 0, None, 'Trigger', {}, True, None, False, ''),
        ('inputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, 0, False, ''),
        ('inputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, True, 0, False, ''),
        ('inputs:semanticFilterName', 'token', 0, None, 'Name of the semantic filter to apply to the semanticLabelToken', {ogn.MetadataKeys.DEFAULT: '"default"'}, True, "default", False, ''),
        ('outputs:exec', 'execution', 0, None, 'Trigger', {}, True, None, False, ''),
        ('outputs:instanceMapSDCudaPtr', 'uint64', 0, None, 'cuda uint16_t buffer pointer of size numInstances containing the instance parent semantic index', {}, True, None, False, ''),
        ('outputs:instanceMappingInfoSDPtr', 'uint64', 0, None, 'uint buffer pointer containing the following information :\n[ numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic,\n  lastUpdateTimeNumeratorHigh, lastUpdateTimeNumeratorLow, , lastUpdateTimeDenominatorHigh, lastUpdateTimeDenominatorLow ]', {}, True, None, False, ''),
        ('outputs:instancePrimTokenSDCudaPtr', 'uint64', 0, None, 'cuda uint64_t buffer pointer of size numInstances containing the instance path token', {}, True, None, False, ''),
        ('outputs:lastUpdateTimeDenominator', 'uint64', 0, None, 'Time denominator of the last time the data has changed', {}, True, None, False, ''),
        ('outputs:lastUpdateTimeNumerator', 'int64', 0, None, 'Time numerator of the last time the data has changed', {}, True, None, False, ''),
        ('outputs:semanticLabelTokenSDCudaPtr', 'uint64', 0, None, 'cuda uint64_t buffer pointer of size numSemantics containing the semantic label token', {}, True, None, False, ''),
        ('outputs:semanticLocalTransformSDCudaPtr', 'uint64', 0, None, 'cuda float44 buffer pointer of size numSemantics containing the local semantic transform', {}, True, None, False, ''),
        ('outputs:semanticMapSDCudaPtr', 'uint64', 0, None, 'cuda uint16_t buffer pointer of size numSemantics containing the semantic parent semantic index', {}, True, None, False, ''),
        ('outputs:semanticPrimTokenSDCudaPtr', 'uint64', 0, None, 'cuda uint32_t buffer pointer of size numSemantics containing the prim part of the semantic path token', {}, True, None, False, ''),
        ('outputs:semanticWorldTransformSDCudaPtr', 'uint64', 0, None, 'cuda float44 buffer pointer of size numSemantics containing the world semantic transform', {}, True, None, False, ''),
    ])

    class tokens:
        InstanceMappingInfoSDhost = "InstanceMappingInfoSDhost"
        SemanticMapSD = "SemanticMapSD"
        SemanticMapSDhost = "SemanticMapSDhost"
        SemanticPrimTokenSD = "SemanticPrimTokenSD"
        SemanticPrimTokenSDhost = "SemanticPrimTokenSDhost"
        InstanceMapSD = "InstanceMapSD"
        InstanceMapSDhost = "InstanceMapSDhost"
        InstancePrimTokenSD = "InstancePrimTokenSD"
        InstancePrimTokenSDhost = "InstancePrimTokenSDhost"
        SemanticLabelTokenSD = "SemanticLabelTokenSD"
        SemanticLabelTokenSDhost = "SemanticLabelTokenSDhost"
        SemanticLocalTransformSD = "SemanticLocalTransformSD"
        SemanticLocalTransformSDhost = "SemanticLocalTransformSDhost"
        SemanticWorldTransformSD = "SemanticWorldTransformSD"
        SemanticWorldTransformSDhost = "SemanticWorldTransformSDhost"

    @classmethod
    def _populate_role_data(cls):
        """Populate a role structure with the non-default roles on this node type"""
        role_data = super()._populate_role_data()
        role_data.inputs.exec = og.AttributeRole.EXECUTION
        role_data.outputs.exec = og.AttributeRole.EXECUTION
        return role_data

    class ValuesForInputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = { }
        """Helper class that creates natural hierarchical access to input attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedReadAttributes = []
            self._batchedReadValues = []

        @property
        def exec(self):
            data_view = og.AttributeValueHelper(self._attributes.exec)
            return data_view.get()

        @exec.setter
        def exec(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.exec)
            data_view = og.AttributeValueHelper(self._attributes.exec)
            data_view.set(value)

        @property
        def gpu(self):
            data_view = og.AttributeValueHelper(self._attributes.gpu)
            return data_view.get()

        @gpu.setter
        def gpu(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.gpu)
            data_view = og.AttributeValueHelper(self._attributes.gpu)
            data_view.set(value)

        @property
        def rp(self):
            data_view = og.AttributeValueHelper(self._attributes.rp)
            return data_view.get()

        @rp.setter
        def rp(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.rp)
            data_view = og.AttributeValueHelper(self._attributes.rp)
            data_view.set(value)

        @property
        def semanticFilterName(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticFilterName)
            return data_view.get()

        @semanticFilterName.setter
        def semanticFilterName(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.semanticFilterName)
            data_view = og.AttributeValueHelper(self._attributes.semanticFilterName)
            data_view.set(value)

        def _prefetch(self):
            readAttributes = self._batchedReadAttributes
            newValues = _og._prefetch_input_attributes_data(readAttributes)
            if len(readAttributes) == len(newValues):
                self._batchedReadValues = newValues

    class ValuesForOutputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = { }
        """Helper class that creates natural hierarchical access to output attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedWriteValues = { }

        @property
        def exec(self):
            data_view = og.AttributeValueHelper(self._attributes.exec)
            return data_view.get()

        @exec.setter
        def exec(self, value):
            data_view = og.AttributeValueHelper(self._attributes.exec)
            data_view.set(value)

        @property
        def instanceMapSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.instanceMapSDCudaPtr)
            return data_view.get()

        @instanceMapSDCudaPtr.setter
        def instanceMapSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.instanceMapSDCudaPtr)
            data_view.set(value)

        @property
        def instanceMappingInfoSDPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.instanceMappingInfoSDPtr)
            return data_view.get()

        @instanceMappingInfoSDPtr.setter
        def instanceMappingInfoSDPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.instanceMappingInfoSDPtr)
            data_view.set(value)

        @property
        def instancePrimTokenSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.instancePrimTokenSDCudaPtr)
            return data_view.get()

        @instancePrimTokenSDCudaPtr.setter
        def instancePrimTokenSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.instancePrimTokenSDCudaPtr)
            data_view.set(value)

        @property
        def lastUpdateTimeDenominator(self):
            data_view = og.AttributeValueHelper(self._attributes.lastUpdateTimeDenominator)
            return data_view.get()

        @lastUpdateTimeDenominator.setter
        def lastUpdateTimeDenominator(self, value):
            data_view = og.AttributeValueHelper(self._attributes.lastUpdateTimeDenominator)
            data_view.set(value)

        @property
        def lastUpdateTimeNumerator(self):
            data_view = og.AttributeValueHelper(self._attributes.lastUpdateTimeNumerator)
            return data_view.get()

        @lastUpdateTimeNumerator.setter
        def lastUpdateTimeNumerator(self, value):
            data_view = og.AttributeValueHelper(self._attributes.lastUpdateTimeNumerator)
            data_view.set(value)

        @property
        def semanticLabelTokenSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticLabelTokenSDCudaPtr)
            return data_view.get()

        @semanticLabelTokenSDCudaPtr.setter
        def semanticLabelTokenSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.semanticLabelTokenSDCudaPtr)
            data_view.set(value)

        @property
        def semanticLocalTransformSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticLocalTransformSDCudaPtr)
            return data_view.get()

        @semanticLocalTransformSDCudaPtr.setter
        def semanticLocalTransformSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.semanticLocalTransformSDCudaPtr)
            data_view.set(value)

        @property
        def semanticMapSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticMapSDCudaPtr)
            return data_view.get()

        @semanticMapSDCudaPtr.setter
        def semanticMapSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.semanticMapSDCudaPtr)
            data_view.set(value)

        @property
        def semanticPrimTokenSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticPrimTokenSDCudaPtr)
            return data_view.get()

        @semanticPrimTokenSDCudaPtr.setter
        def semanticPrimTokenSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.semanticPrimTokenSDCudaPtr)
            data_view.set(value)

        @property
        def semanticWorldTransformSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.semanticWorldTransformSDCudaPtr)
            return data_view.get()

        @semanticWorldTransformSDCudaPtr.setter
        def semanticWorldTransformSDCudaPtr(self, value):
            data_view = og.AttributeValueHelper(self._attributes.semanticWorldTransformSDCudaPtr)
            data_view.set(value)

        def _commit(self):
            _og._commit_output_attributes_data(self._batchedWriteValues)
            self._batchedWriteValues = { }

    class ValuesForState(og.DynamicAttributeAccess):
        """Helper class that creates natural hierarchical access to state attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)

    def __init__(self, node):
        super().__init__(node)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
        self.inputs = OgnSdPostInstanceMappingDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnSdPostInstanceMappingDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnSdPostInstanceMappingDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
