/*
 * Go2PartOpeningAngle.c
 * 
 * Gocator system communication library
 * Copyright (C) 2013 by LMI Technologies Inc.
 * 
 * Licensed under The MIT License.
 * Redistributions of files must retain the above copyright notice.
 */

#include <z/Go2Measurements/zGo2PartOpeningAngle.h>
#include <z/zGo2PartTypes.h>
#include <z/zGo2System.h>
#include <string.h>

/*
 * Go2PartOpeningAngle Class 
 */

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_Construct(Go2PartOpeningAngle* measurement, Go2UInt32 id, Go2Object system)
{
    Go2PartOpeningAngle output = zNIL; 
    Go2Status status = zOK; 

    zCHECK(zCalloc(&output, 1, sizeof(Go2PartOpeningAngleClass))); 

    if (!zSUCCESS(status = Go2PartOpeningAngle_Init(output, id, system)))
    {
        zCHECK(Go2Object_Destroy(output)); 
        return status; 
    }

    *measurement = output; 

    return GO2_OK; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_Init(Go2PartOpeningAngle measurement, Go2UInt32 id, Go2Object system)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    z32u i; 

    zCHECK(Go2PartMeasurement_Init(measurement, GO2_TYPE_PART_OPENING_ANGLE, id, system)); 

    obj->Release = Go2PartOpeningAngle_VRelease;
    obj->Read = Go2PartOpeningAngle_VRead; 
    obj->Write = Go2PartOpeningAngle_VWrite; 

    obj->openingType = GO2_PART_OPENING_TYPE_ROUNDED_SLOT;

    obj->nominalLength = 20.0;
    obj->nominalWidth = 10.0;
    obj->nominalAngle = 0.0;
    obj->nominalRadius = 5.0;
    obj->lengthTolerance = 4.0;
    obj->widthTolerance = 2.0;
    obj->angleTolerance = 5.0;
    obj->partialDetectionEnabled = GO2_FALSE;

    for (i = 0; i < zCOUNT(obj->refRegions); ++i)
    {
        zCHECK(Go2PartRegion2d_Construct(&obj->refRegions[i], system));
    }
    //construct all ref areas, but initialize the measurement to only use 2
    obj->refRegionCount = 2;

    obj->refRegionsEnabled = GO2_FALSE;
    obj->autoRefRegionEnabled = GO2_TRUE;
    obj->autoTiltCorrectionEnabled = GO2_TRUE;
    obj->tiltXAngle = 0.0;
    obj->tiltYAngle = 0.0;

    return GO2_OK; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_VRelease(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    z32u i; 

    for (i = 0; i < zCOUNT(obj->refRegions); ++i)
    {
        zCHECK(Go2Object_Destroy(obj->refRegions[i])); 
    }

    zCHECK(Go2PartMeasurement_VRelease(measurement));  
        
    return GO2_OK; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_VRead(Go2PartOpeningAngle measurement, zXml xml, zXmlItem item)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    zXmlItem regionItem = zNIL;

    zCHECK(Go2PartMeasurement_VRead(measurement, xml, item)); 

    obj->refRegionCount = 0; 
    //ensure we at least have one refArea
    zCHECK(!zIS_NIL(regionItem = zXml_Child(xml, item, "RefRegions/RefRegion")));     
    while (!zIS_NIL(regionItem))
    {
        zCHECK(Go2PartRegion2d_Read(obj->refRegions[obj->refRegionCount], xml, regionItem));  
        obj->refRegionCount++;  
        regionItem = zXml_NextSibling(xml, regionItem);
    }
    
    zCHECK(zXml_Child32s(xml, item, "Type", (z32s*) &obj->openingType)); 

    zCHECK(zXml_Child64f(xml, item, "NominalRadius", &obj->nominalRadius)); 
    zCHECK(zXml_Child64f(xml, item, "NominalLength", &obj->nominalLength)); 
    zCHECK(zXml_Child64f(xml, item, "NominalWidth", &obj->nominalWidth)); 
    zCHECK(zXml_Child64f(xml, item, "NominalAngle", &obj->nominalAngle)); 
    zCHECK(zXml_Child64f(xml, item, "LengthTolerance", &obj->lengthTolerance)); 
    zCHECK(zXml_Child64f(xml, item, "WidthTolerance", &obj->widthTolerance)); 
    zCHECK(zXml_Child64f(xml, item, "AngleTolerance", &obj->angleTolerance)); 
    zCHECK(zXml_Child32s(xml, item, "PartialDetectionEnabled", &obj->partialDetectionEnabled));

    zCHECK(zXml_Child32s(xml, item, "RefRegionsEnabled", &obj->refRegionsEnabled));
    zCHECK(zXml_Child32s(xml, item, "AutoRefRegionEnabled", &obj->autoRefRegionEnabled));
    zCHECK(zXml_Child32s(xml, item, "AutoTiltCorrectionEnabled", &obj->autoTiltCorrectionEnabled));
    zCHECK(zXml_Child64f(xml, item, "TiltXAngle", &obj->tiltXAngle)); 
    zCHECK(zXml_Child64f(xml, item, "TiltYAngle", &obj->tiltYAngle)); 

    return GO2_OK; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_VWrite(Go2PartOpeningAngle  measurement, zXml xml, zXmlItem item)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    zXmlItem regionItem = zNIL;
    zXmlItem refRegionItem = zNIL;
    z32u i; 

    zCHECK(Go2PartMeasurement_VWrite(measurement, xml, item)); 

    zCHECK(zXml_AddItem(xml, item, "RefRegions", &refRegionItem));  
    for (i = 0; i < obj->refRegionCount; ++i)
    {
        zCHECK(zXml_AddItem(xml, refRegionItem, "RefRegion", &regionItem)); 
        zCHECK(Go2PartRegion2d_Write(obj->refRegions[i], xml, regionItem)); 
    }

    zCHECK(zXml_SetChild32s(xml, item, "Type", (z32s) obj->openingType)); 

    zCHECK(zXml_SetChild64f(xml, item, "NominalRadius", obj->nominalRadius)); 
    zCHECK(zXml_SetChild64f(xml, item, "NominalLength", obj->nominalLength)); 
    zCHECK(zXml_SetChild64f(xml, item, "NominalWidth", obj->nominalWidth)); 
    zCHECK(zXml_SetChild64f(xml, item, "NominalAngle", obj->nominalAngle)); 
    zCHECK(zXml_SetChild64f(xml, item, "LengthTolerance", obj->lengthTolerance)); 
    zCHECK(zXml_SetChild64f(xml, item, "WidthTolerance", obj->widthTolerance)); 
    zCHECK(zXml_SetChild64f(xml, item, "AngleTolerance", obj->angleTolerance)); 
    zCHECK(zXml_SetChild32s(xml, item, "PartialDetectionEnabled", obj->partialDetectionEnabled)); 

    zCHECK(zXml_SetChild32s(xml, item, "RefRegionsEnabled", obj->refRegionsEnabled)); 
    zCHECK(zXml_SetChild32s(xml, item, "AutoRefRegionEnabled", obj->autoRefRegionEnabled)); 
    zCHECK(zXml_SetChild32s(xml, item, "AutoTiltCorrectionEnabled", obj->autoTiltCorrectionEnabled)); 
    zCHECK(zXml_SetChild64f(xml, item, "TiltXAngle", obj->tiltXAngle)); 
    zCHECK(zXml_SetChild64f(xml, item, "TiltYAngle", obj->tiltYAngle)); 

    return GO2_OK; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetId(Go2PartOpeningAngle measurement, Go2UInt32 id)
{
    return Go2Measurement_SetId(measurement, id); 
}

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_Id(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_Id(measurement); 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetName(Go2PartOpeningAngle measurement, const Go2Char* name)
{
    return Go2Measurement_SetName(measurement, name); 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_Name(Go2PartOpeningAngle measurement, Go2Char* name, Go2UInt32 capacity)
{
    return Go2Measurement_Name(measurement, name, capacity); 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetDecisionMin(Go2PartOpeningAngle measurement, Go2Double min)
{
    return Go2Measurement_SetDecisionMin(measurement, min); 
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_DecisionMin(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_DecisionMin(measurement); 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetDecisionMax(Go2PartOpeningAngle measurement, Go2Double max)
{
    return Go2Measurement_SetDecisionMax(measurement, max); 
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_DecisionMax(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_DecisionMax(measurement); 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableHold(Go2PartOpeningAngle measurement, Go2Bool enable)
{
    return Go2Measurement_EnableHold(measurement, enable);  
} 

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_HoldEnabled(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_HoldEnabled(measurement);  
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableSmoothing(Go2PartOpeningAngle measurement, Go2Bool enable)
{
    return Go2Measurement_EnableSmoothing(measurement, enable);  
} 

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_SmoothingEnabled(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_SmoothingEnabled(measurement);  
} 

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_SmoothingWindowMin(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_SmoothingWindowMin(measurement);  
} 

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_SmoothingWindowMax(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_SmoothingWindowMax(measurement);  
} 

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetSmoothingWindow(Go2PartOpeningAngle measurement, Go2UInt32 window)
{
    return Go2Measurement_SetSmoothingWindow(measurement, window);  
} 

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_SmoothingWindow(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_SmoothingWindow(measurement);  
} 

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetType(Go2PartOpeningAngle measurement, Go2PartOpeningType type)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    obj->openingType = type; 
    zCHECK(Go2System_SetModified(obj->system)); 

    return GO2_OK; 
}

GO2_EXPORT(Go2PartOpeningType) Go2PartOpeningAngle_Type(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    return obj->openingType; 
}

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_RefRegionCount(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->refRegionCount;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetRefRegionCount(Go2PartOpeningAngle measurement, Go2UInt32 count)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    Go2Status status = GO2_OK;

    if(count > zCOUNT(obj->refRegions)){
        return GO2_ERROR_PARAMETER;
    }
    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    status = Go2System_Set32u(obj->system, &obj->refRegionCount, count, 1, GO2_MAX_REF_REGIONS); 
    zCHECK(Go2System_SetModified(obj->system)); 

    return status;      
}

GO2_EXPORT(Go2PartRegion2d) Go2PartOpeningAngle_RefRegionAt(Go2PartOpeningAngle measurement, Go2UInt32 index)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->refRegions[index];      
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_NominalLength(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->nominalLength;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetNominalLength(Go2PartOpeningAngle measurement, Go2Double radius)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->nominalLength, radius, 0.0, z64F_MAX);        
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_NominalWidth(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->nominalWidth;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetNominalWidth(Go2PartOpeningAngle measurement, Go2Double radius)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->nominalWidth, radius, 0.0, z64F_MAX);        
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_NominalAngle(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->nominalAngle;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetNominalAngle(Go2PartOpeningAngle measurement, Go2Double radius)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->nominalAngle, radius, -z64F_MAX, z64F_MAX);        
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_NominalRadius(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->nominalRadius;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetNominalRadius(Go2PartOpeningAngle measurement, Go2Double radius)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->nominalRadius, radius, 0.0, z64F_MAX);        
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_LengthTolerance(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->lengthTolerance;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetLengthTolerance(Go2PartOpeningAngle measurement, Go2Double tolerance)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->lengthTolerance, tolerance, 0.0, z64F_MAX);   
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_WidthTolerance(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->widthTolerance;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetWidthTolerance(Go2PartOpeningAngle measurement, Go2Double tolerance)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->widthTolerance, tolerance, 0.0, z64F_MAX);   
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_AngleTolerance(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 
    return obj->angleTolerance;      
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetAngleTolerance(Go2PartOpeningAngle measurement, Go2Double tolerance)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->angleTolerance, tolerance, 0.0, z64F_MAX);   
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_AutoRefRegionEnabled(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    return obj->autoRefRegionEnabled; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableAutoRefRegion(Go2PartOpeningAngle measurement, Go2Bool enable)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    obj->autoRefRegionEnabled = enable; 
    zCHECK(Go2System_SetModified(obj->system)); 

    return GO2_OK;
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_AutoTiltCorrectionEnabled(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    return obj->autoTiltCorrectionEnabled; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableAutoTiltCorrection(Go2PartOpeningAngle measurement, Go2Bool enable)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    obj->autoTiltCorrectionEnabled = enable; 
    zCHECK(Go2System_SetModified(obj->system)); 

    return GO2_OK;
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_TiltXAngle(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    return obj->tiltXAngle; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetTiltXAngle(Go2PartOpeningAngle measurement, Go2Double tiltXAngle)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->tiltXAngle, tiltXAngle, -z64F_MAX, z64F_MAX);   
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_TiltYAngle(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);
    return obj->tiltYAngle; 
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetTiltYAngle(Go2PartOpeningAngle measurement, Go2Double tiltYAngle)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return Go2System_Set64f(obj->system, &obj->tiltYAngle, tiltYAngle, -z64F_MAX, z64F_MAX);   
}



GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetScale(Go2PartOpeningAngle measurement, Go2Double scale){
    return Go2Measurement_SetScale(measurement, scale);
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_Scale(Go2PartOpeningAngle measurement){
    return Go2Measurement_Scale(measurement);
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetOffset(Go2PartOpeningAngle measurement, Go2Double offset){
    return Go2Measurement_SetOffset(measurement, offset);
}

GO2_EXPORT(Go2Double) Go2PartOpeningAngle_Offset(Go2PartOpeningAngle measurement){
    return Go2Measurement_Offset(measurement);
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnablePartialDetection(Go2PartOpeningAngle measurement, Go2Bool enabled) 
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    obj->partialDetectionEnabled = enabled;
    zCHECK(Go2System_SetModified(obj->system));

    return GO2_OK;
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_PartialDetectionEnabled(Go2Script measurement) 
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement); 

    return obj->partialDetectionEnabled;
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableLink(Go2PartOpeningAngle measurement, Go2Bool enable)  
{
    return Go2Measurement_EnableLink(measurement, enable);  
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_LinkEnabled(Go2PartOpeningAngle measurement)  
{
    return Go2Measurement_LinkEnabled(measurement);  
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_SetLink(Go2PartOpeningAngle measurement, Go2UInt32 link) 
{
    return Go2Measurement_SetLink(measurement, link); 
}

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_Link(Go2PartOpeningAngle measurement) 
{
    return Go2Measurement_Link(measurement); 
}

GO2_EXPORT(Go2PartRegion3d) Go2PartOpeningAngle_Region(Go2PartOpeningAngle measurement)
{
    return Go2PartMeasurement_Region(measurement);
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableRegion(Go2PartOpeningAngle measurement, Go2Bool enable)  
{
    return Go2PartMeasurement_EnableRegion(measurement, enable);  
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_RegionEnabled(Go2PartOpeningAngle measurement)  
{
    return Go2PartMeasurement_RegionEnabled(measurement);  
}

GO2_EXPORT(Go2Bool) Go2PartOpeningAngle_RefRegionsEnabled(Go2PartOpeningAngle measurement)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    return obj->refRegionsEnabled;
}

GO2_EXPORT(Go2Status) Go2PartOpeningAngle_EnableRefRegions(Go2PartOpeningAngle measurement, Go2Bool enable)
{
    Go2PartOpeningAngleClass* obj = zHANDLE_POINTER(measurement);

    zCHECK(Go2System_CheckConfigurable(obj->system)); 
    obj->refRegionsEnabled = enable;
    zCHECK(Go2System_SetModified(obj->system));

    return GO2_OK;
}

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_LinkOptionCount(Go2PartOpeningAngle measurement)
{
    return Go2Measurement_LinkOptionCount(measurement);
}

GO2_EXPORT(Go2UInt32) Go2PartOpeningAngle_LinkOptionAt(Go2PartOpeningAngle measurement, Go2UInt32 index)
{
    return Go2Measurement_LinkOptionAt(measurement, index);
}
