1247 lines
47 KiB
C
1247 lines
47 KiB
C
/**
|
|
* @file GoFeatures.c
|
|
*
|
|
* @internal
|
|
* Copyright (C) 2017-2021 by LMI Technologies Inc.
|
|
* Licensed under the MIT License.
|
|
* Redistributed files must retain the above copyright notice.
|
|
*/
|
|
#include <GoSdk/Tools/GoFeatures.h>
|
|
#include <GoSdk/GoSensor.h>
|
|
#include <GoSdk/Tools/GoExtParams.h>
|
|
#include <GoSdk/GoUtils.h>
|
|
|
|
kBeginStaticClassEx(Go, GoFeatures)
|
|
kEndStaticClassEx()
|
|
|
|
GoFx(kStatus) xGoFeatures_InitStatic()
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
|
|
kCheck(kArrayList_Construct(&sobj->nameTypeMapList, kTypeOf(GoFeaturesNameTypeMapping), 0, kNULL));
|
|
|
|
kCheck(GoFeatures_CreateNameTypeMap());
|
|
|
|
return kOK;
|
|
|
|
}
|
|
GoFx(kStatus) xGoFeatures_ReleaseStatic()
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
|
|
kObject_Destroy(sobj->nameTypeMapList);
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kSize) GoFeatures_NameTypeMapEntryCount(void)
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
return kArrayList_Count(sobj->nameTypeMapList);
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_NameTypeMapAdd(const char* name, const char* featureName, kType featureType)
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
GoFeaturesNameTypeMapping map;
|
|
|
|
kCheck(kStrCopy(map.lookupName, kCountOf(map.lookupName), name));
|
|
kCheck(kStrCopy(map.featureName, kCountOf(map.featureName), featureName));
|
|
map.featureType = featureType;
|
|
|
|
kCheck(kArrayList_AddT(sobj->nameTypeMapList, &map));
|
|
|
|
|
|
return kOK;
|
|
}
|
|
|
|
// This function is the runtime equivalent of defining a static mapping table.
|
|
GoFx(kStatus) GoFeatures_NameTypeMapInit(void)
|
|
{
|
|
kStatus exception;
|
|
|
|
kTry
|
|
{
|
|
// NOTE: In the table, the first parameter is a concatenation of tool name and feature name.
|
|
//
|
|
// GOC-14127: older (pre-6.1) SDK messes up writing the XML config by always marking GDK tools as "Custom"
|
|
// regardless of whether the GDK tool is a USER GDK tool or INTERNAL GDK tool.
|
|
// Users can sometimes end up messing up the XML config if user uses both SDK and Gocator GUI to configure a sensor.
|
|
// One example of a messed up XML config is where the tool name is GO_EXT_TOOL_NAME_TOOL
|
|
// but feature is GO_FEATURES_NAME_CUSTOM.
|
|
//
|
|
// GDK tool name -> GDK tool type mapping:
|
|
// In general, mapping of GDK tool name to GDK tool type to GoExtFeature should be lenient and allow even
|
|
// invalid combinations of GDK tool/feature combinations.
|
|
// So put all the possible combinations for GDK tool, even if most of the time they do not
|
|
// or should not happen, that map to GoExtFeature into the mapping table.
|
|
//
|
|
// NOTE:
|
|
// For USER GDK tools, tool name is GO_EXT_TOOL_NAME_CUSTOM and feature name should be GO_FEATURES_NAME_CUSTOM.
|
|
// For INTERNAL GDK tools, tool name is GO_EXT_TOOL_NAME_TOOL and feature name should be GO_FEATURES_NAME_FEATURE.
|
|
// So the normal combinations for mapping to type GoExtFeature are:
|
|
// 1. GO_EXT_TOOL_NAME_CUSTOM GO_FEATURES_NAME_CUSTOM
|
|
// 2. GO_EXT_TOOL_NAME_TOOL GO_FEATURES_NAME_FEATURE
|
|
// The abnormal combinations are:
|
|
// 3. GO_EXT_TOOL_NAME_TOOL GO_FEATURES_NAME_CUSTOM
|
|
// 4. GO_EXT_TOOL_NAME_CUSTOM GO_FEATURES_NAME_FEATURE
|
|
//
|
|
// GDK tool type -> GDK tool name mapping.
|
|
// This table has multiple entries for GoExtFeature type.
|
|
// For mapping GoExtFeature to a feature name, search stops when the first entry with type GoExtFeature is found.
|
|
// In this case, the first entry added to the map above is the one and therefore will always return
|
|
// GO_FEATURES_NAME_CUSTOM which is correct only for USER GDK tool.
|
|
// To support INTERNAL GDK tool, this table cannot be used. Instead, extra code is needed to explicitly handle
|
|
// INTERNAL GDK tool by bypassing this table. See GoFeatures_FormatTypeExtToolFormat().
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_CUSTOM GO_FEATURES_NAME_CUSTOM, GO_FEATURES_NAME_CUSTOM, kTypeOf(GoExtFeature)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_TOOL GO_FEATURES_NAME_FEATURE, GO_FEATURES_NAME_FEATURE, kTypeOf(GoExtFeature)));
|
|
|
|
// GOC-14127: Add support for these abnormal combinations, for leniency reasons.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_TOOL GO_FEATURES_NAME_CUSTOM, GO_FEATURES_NAME_FEATURE, kTypeOf(GoExtFeature)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_CUSTOM GO_FEATURES_NAME_FEATURE, GO_FEATURES_NAME_CUSTOM, kTypeOf(GoExtFeature)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_POSITION GO_FEATURES_NAME_POINT, GO_FEATURES_NAME_POINT, kTypeOf(GoProfilePositionPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_LINE GO_FEATURES_NAME_LINE, GO_FEATURES_NAME_LINE, kTypeOf(GoProfileLineLine)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_LINE GO_FEATURES_NAME_ERROR_MIN_POINT, GO_FEATURES_NAME_ERROR_MIN_POINT, kTypeOf(GoProfileLineMinErrorPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_LINE GO_FEATURES_NAME_ERROR_MAX_POINT, GO_FEATURES_NAME_ERROR_MAX_POINT, kTypeOf(GoProfileLineMaxErrorPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_INTERSECT GO_FEATURES_NAME_INTERSECT_POINT, GO_FEATURES_NAME_INTERSECT_POINT, kTypeOf(GoProfileIntersectIntersectPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_INTERSECT GO_FEATURES_NAME_LINE, GO_FEATURES_NAME_LINE, kTypeOf(GoProfileIntersectLine)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_INTERSECT GO_FEATURES_NAME_BASELINE, GO_FEATURES_NAME_BASELINE, kTypeOf(GoProfileIntersectBaseLine)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_BOUNDING_BOX GO_FEATURES_NAME_CORNER_POINT, GO_FEATURES_NAME_CORNER_POINT, kTypeOf(GoProfileBoundingBoxCornerPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_BOUNDING_BOX GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoProfileBoundingBoxCenterPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_AREA GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoProfileAreaCenterPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_CIRCLE GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoProfileCircleCenterPoint)));
|
|
|
|
// TODO: confirm profile dimension has a feature or not.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_DIMENSION GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoProfileDimensionCenterPoint)));
|
|
|
|
// TODO: confirm if profile panel has features or not.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_PANEL GO_FEATURES_NAME_LEFT_GAP_POINT, GO_FEATURES_NAME_LEFT_GAP_POINT, kTypeOf(GoProfilePanelLeftGapPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_PANEL GO_FEATURES_NAME_LEFT_FLUSH_POINT, GO_FEATURES_NAME_LEFT_FLUSH_POINT, kTypeOf(GoProfilePanelLeftFlushPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_PANEL GO_FEATURES_NAME_RIGHT_GAP_POINT, GO_FEATURES_NAME_RIGHT_GAP_POINT, kTypeOf(GoProfilePanelRightGapPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_PANEL GO_FEATURES_NAME_RIGHT_FLUSH_POINT, GO_FEATURES_NAME_RIGHT_FLUSH_POINT, kTypeOf(GoProfilePanelRightFlushPoint)));
|
|
|
|
// TODO: confirm if round corner has a feature or not.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_ROUND_CORNER GO_FEATURES_NAME_POINT, GO_FEATURES_NAME_POINT, kTypeOf(GoProfileRoundCornerPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_ROUND_CORNER GO_FEATURES_NAME_EDGE_POINT, GO_FEATURES_NAME_EDGE_POINT, kTypeOf(GoProfileRoundCornerEdgePoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_PROFILE_TOOL_NAME_ROUND_CORNER GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoProfileRoundCornerCenterPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_BOUNDING_BOX GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceBoundingBoxCenterPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_BOUNDING_BOX GO_FEATURES_NAME_AXIS_LINE, GO_FEATURES_NAME_AXIS_LINE, kTypeOf(GoSurfaceBoundingBoxAxisLine)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_COUNTERSUNK_HOLE GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceCountersunkHoleCenterPoint)));
|
|
// TODO: confirm if surface dimension tool has a feature or not.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_DIMENSION GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceDimensionCenterPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_SURFACE_EDGE GO_FEATURES_NAME_EDGE_LINE, GO_FEATURES_NAME_EDGE_LINE, kTypeOf(GoSurfaceEdgeEdgeLine)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_EXT_TOOL_NAME_SURFACE_EDGE GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceEdgeCenterPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_ELLIPSE GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceEllipseCenterPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_ELLIPSE GO_FEATURES_NAME_MAJOR_AXIS_LINE, GO_FEATURES_NAME_MAJOR_AXIS_LINE, kTypeOf(GoSurfaceEllipseMajorAxisLine)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_ELLIPSE GO_FEATURES_NAME_MINOR_AXIS_LINE, GO_FEATURES_NAME_MINOR_AXIS_LINE, kTypeOf(GoSurfaceEllipseMinorAxisLine)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_OPENING GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceOpeningCenterPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_PLANE GO_FEATURES_NAME_PLANE, GO_FEATURES_NAME_PLANE, kTypeOf(GoSurfacePlanePlane)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_POSITION GO_FEATURES_NAME_POINT, GO_FEATURES_NAME_POINT, kTypeOf(GoSurfacePositionPoint)));
|
|
// TODO: check if original code was missing GoSurfaceHoleCenterPoint because tool has feature.
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_HOLE GO_FEATURES_NAME_CENTER_POINT, GO_FEATURES_NAME_CENTER_POINT, kTypeOf(GoSurfaceHoleCenterPoint)));
|
|
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_STUD GO_FEATURES_NAME_TIP_POINT, GO_FEATURES_NAME_TIP_POINT, kTypeOf(GoSurfaceStudTipPoint)));
|
|
kTest(GoFeatures_NameTypeMapAdd(GO_SURFACE_TOOL_NAME_STUD GO_FEATURES_NAME_BASE_POINT, GO_FEATURES_NAME_BASE_POINT, kTypeOf(GoSurfaceStudBasePoint)));
|
|
}
|
|
kCatch(&exception)
|
|
{
|
|
// During development, fail hard if there are map table issues
|
|
// such as the table being too small for all the entries.
|
|
kAssert(0);
|
|
kEndCatch(exception);
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_CreateNameTypeMap(void)
|
|
{
|
|
kCheck(GoFeatures_NameTypeMapInit());
|
|
|
|
// The table should have at least one entry.
|
|
kCheckTrue((GoFeatures_NameTypeMapEntryCount() > 0), kERROR);
|
|
|
|
// Table is now available.
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_ParseTypeHelper(const kChar* name, kType* type)
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
kSize i;
|
|
GoFeaturesNameTypeMapping *map;
|
|
|
|
for (i = 0; i < kArrayList_Count(sobj->nameTypeMapList); ++i)
|
|
{
|
|
map = kArrayList_AtT(sobj->nameTypeMapList, i, GoFeaturesNameTypeMapping);
|
|
if (kStrCompare(map->lookupName, name) == 0)
|
|
{
|
|
*type = map->featureType;
|
|
return kOK;
|
|
}
|
|
}
|
|
|
|
return kERROR_NOT_FOUND;
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_ParseType(const kChar* toolName, const kChar* featureName, kType* type)
|
|
{
|
|
kChar* featureType = kNULL;
|
|
kSize capacity = kStrLength(toolName) + kStrLength(featureName) + 1;
|
|
|
|
kTry
|
|
{
|
|
// Concatenate the tool name and feature name to form
|
|
// the lookup name.
|
|
kTest(kMemAllocZero(sizeof(kChar) * capacity, &featureType));
|
|
kTest(kStrCopy(featureType, capacity, toolName));
|
|
kTest(kStrCat(featureType, capacity, featureName));
|
|
|
|
kTest(GoFeatures_ParseTypeHelper(featureType, type));
|
|
}
|
|
kFinally
|
|
{
|
|
if (featureType)
|
|
{
|
|
// Want to propagate the original failure in the try block so
|
|
// don't check this memory free operation.
|
|
kMemFree(featureType);
|
|
}
|
|
kEndFinally();
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_FormatTypeHelper(kType feature, const kChar** outputPtr)
|
|
{
|
|
kStaticObj(GoFeatures);
|
|
kSize i;
|
|
GoFeaturesNameTypeMapping map;
|
|
|
|
for (i = 0; i < kArrayList_Count(sobj->nameTypeMapList); ++i)
|
|
{
|
|
map = *kArrayList_AtT(sobj->nameTypeMapList, i, GoFeaturesNameTypeMapping);
|
|
if (feature == map.featureType)
|
|
{
|
|
*outputPtr = map.featureName;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
// Pre-existing call before GOC-14127 that only uses the mapping
|
|
// table to map feature type to feature name.
|
|
// Does not handle INTERNAL GDK tools, only USER GDK tools.
|
|
// GoFeatures_FormatTypeExtToolFormat() adds support for INTERNAL
|
|
// GDK tool mapping of feature type to feature name.
|
|
GoFx(kStatus) GoFeatures_FormatType(kType feature, kChar* featureTypeName, kSize capacity)
|
|
{
|
|
const kChar* output = kNULL;
|
|
|
|
kCheck(GoFeatures_FormatTypeHelper(feature, &output));
|
|
|
|
kCheck(kStrCopy(featureTypeName, capacity, output));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
// GOC-14127: This function is called internally by the SDK to get the feature type name.
|
|
// The mapping table always maps GoExtFeature to GO_FEATURES_NAME_CUSTOM (ie. USER GDK
|
|
// tool) and cannot support returning GO_FEATURES_NAME_FEATURE for INTERNAL
|
|
// GDK tool GoExtFeature.
|
|
// This API accepts a flag indicating if the feature is from
|
|
// a INTERNAL tool or not, and return GO_FEATURES_NAME_FEATURE for
|
|
// INTERNAL tool features.
|
|
GoFx(kStatus) GoFeatures_FormatTypeExtToolFormat(kType feature, kBool internalTool, kChar* featureTypeName, kSize capacity)
|
|
{
|
|
const kChar* output = kNULL;
|
|
|
|
if (internalTool)
|
|
{
|
|
// Internal GDK format tool XML node feature should be called GO_FEATURES_NAME_FEATURE.
|
|
// Older SDKs might have labelled the feature as GO_FEATURES_NAME_CUSTOM, so ignore what
|
|
// is read and set the feature name to the correct internal GDK tool feature name.
|
|
output = GO_FEATURES_NAME_FEATURE;
|
|
}
|
|
else
|
|
{
|
|
// Format is standard tool format, or USER GDK tool or not set (unknown),
|
|
// so use the name from the mapping table.
|
|
kCheck(GoFeatures_FormatTypeHelper(feature, &output));
|
|
}
|
|
|
|
kCheck(kStrCopy(featureTypeName, capacity, output));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
kBeginClassEx(Go, GoExtFeature)
|
|
kAddVMethod(GoExtFeature, GoFeature, VInit)
|
|
kAddVMethod(GoExtFeature, GoFeature, VRead)
|
|
kAddVMethod(GoExtFeature, GoFeature, VWrite)
|
|
kAddVMethod(GoExtFeature, kObject, VRelease)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoExtFeature_Construct(GoExtFeature* feature, kType type, kObject sensor, kObject srcTool, kAlloc allocator)
|
|
{
|
|
kAlloc alloc = kAlloc_Fallback(allocator);
|
|
kStatus status;
|
|
|
|
kCheck(kAlloc_GetObject(alloc, type, feature));
|
|
|
|
if (!kSuccess(status = kType_VTableT(type, GoFeature)->VInit(*feature, type, sensor, srcTool, alloc)))
|
|
{
|
|
kAlloc_FreeRef(alloc, feature);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
GoFx(kStatus) GoExtFeature_VInit(GoExtFeature feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kObjR(GoExtFeature, feature);
|
|
kStatus exception;
|
|
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_EXTENSIBLE, sensor, srcTool, GO_FEATURE_DATA_UNKNOWN, alloc));
|
|
obj->params = kNULL;
|
|
|
|
kTry
|
|
{
|
|
kTest(GoExtParams_Construct(&obj->params, sensor, alloc));
|
|
}
|
|
kCatch(&exception)
|
|
{
|
|
GoExtFeature_VRelease(feature);
|
|
kEndCatch(exception);
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoExtFeature_VRead(GoExtFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoExtFeature, feature);
|
|
kXmlItem paramsItem = kNULL;
|
|
kText64 tempStr;
|
|
|
|
obj->base.xml = xml;
|
|
obj->base.xmlItem = item;
|
|
|
|
if (!kSuccess(kXml_Attr32s(xml, item, "id", &obj->base.id)))
|
|
{
|
|
obj->base.id = GO_FEATURE_UNASSIGNED_ID;
|
|
}
|
|
|
|
kCheck(kXml_ChildText(xml, item, "Name", obj->base.name, kCountOf(obj->base.name)));
|
|
|
|
kCheck(kXml_ChildBool(xml, item, "Enabled", &obj->base.enabled));
|
|
|
|
kCheck(kXml_AttrText(xml, item, "dataType", tempStr, kCountOf(tempStr)));
|
|
kCheck(GoFeatures_ParseDataType(tempStr, &obj->base.dataType));
|
|
|
|
kCheck(kXml_AttrText(xml, item, "type", obj->base.type, kCountOf(obj->base.type)));
|
|
if (kXml_ChildExists(xml, item, "Parameters"))
|
|
{
|
|
kCheck(!kIsNull(paramsItem = kXml_Child(xml, item, "Parameters")));
|
|
kCheck(GoExtParams_Read(obj->params, xml, paramsItem));
|
|
}
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoExtFeature_VWrite(GoExtFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoExtFeature, feature);
|
|
kXmlItem paramsItem = kNULL;
|
|
kText64 tempStr;
|
|
|
|
kCheck(kXml_SetAttr32s(xml, item, "id", obj->base.id));
|
|
kCheck(kXml_SetChildText(xml, item, "Name", obj->base.name));
|
|
|
|
kCheck(kXml_SetChildBool(xml, item, "Enabled", obj->base.enabled));
|
|
|
|
if (obj->base.dataType != GO_FEATURE_DATA_UNKNOWN)
|
|
{
|
|
kCheck(GoFeatures_FormatDataType(obj->base.dataType, tempStr, kCountOf(tempStr)));
|
|
kCheck(kXml_SetAttrText(xml, item, "dataType", tempStr));
|
|
}
|
|
|
|
//kCheck(GoFeatures_FormatType(kObject_Type(feature), tempStr, kCountOf(tempStr)));
|
|
kCheck(kXml_SetAttrText(xml, item, "type", obj->base.type));
|
|
|
|
kCheck(GoUtils_XmlMerge(obj->base.xml, obj->base.xmlItem, xml, item));
|
|
|
|
kCheck(kXml_AddItem(xml, item, "Parameters", ¶msItem));
|
|
kCheck(GoExtParams_Write(obj->params, xml, paramsItem));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoExtFeature_VRelease(GoExtFeature feature)
|
|
{
|
|
kObj(GoExtFeature, feature);
|
|
|
|
kCheck(kDisposeRef(&obj->params));
|
|
|
|
return GoFeature_VRelease(feature);
|
|
}
|
|
|
|
GoFx(kSize) GoExtFeature_CustomParameterCount(GoExtFeature feature)
|
|
{
|
|
kObj(GoExtFeature, feature);
|
|
kObjN(GoFeature, baseobj, feature);
|
|
|
|
GoSensor_SyncConfig(baseobj->sensor);
|
|
|
|
return GoExtParams_ParameterCount(obj->params);
|
|
}
|
|
|
|
GoFx(GoExtParam) GoExtFeature_CustomParameterAt(GoExtFeature feature, kSize index)
|
|
{
|
|
kObj(GoExtFeature, feature);
|
|
kObjN(GoFeature, baseobj, feature);
|
|
|
|
GoSensor_SyncConfig(baseobj->sensor);
|
|
|
|
return GoExtParams_ParameterAt(obj->params, index);
|
|
}
|
|
|
|
|
|
GoFx(kStatus) GoFeatures_ParseDataType(const kChar* featureDataType, GoFeatureType* type)
|
|
{
|
|
if (strcmp(featureDataType, "PointFeature") == 0) *type = GO_FEATURE_DATA_POINT;
|
|
else if (strcmp(featureDataType, "LineFeature") == 0) *type = GO_FEATURE_DATA_LINE;
|
|
else if (strcmp(featureDataType, "CircleFeature") == 0) *type = GO_FEATURE_DATA_CIRCLE;
|
|
else if (strcmp(featureDataType, "PlaneFeature") == 0) *type = GO_FEATURE_DATA_PLANE;
|
|
else
|
|
{
|
|
*type = GO_FEATURE_DATA_UNKNOWN;
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoFeatures_FormatDataType(GoFeatureDataType type, kChar* featureDataType, kSize capacity)
|
|
{
|
|
kStatus status = kOK;
|
|
const kChar* output = kNULL;
|
|
|
|
switch (type)
|
|
{
|
|
case GO_FEATURE_DATA_POINT : output = "PointFeature"; break;
|
|
case GO_FEATURE_DATA_LINE : output = "LineFeature"; break;
|
|
case GO_FEATURE_DATA_CIRCLE : output = "CircleFeature"; break;
|
|
case GO_FEATURE_DATA_PLANE : output = "PlaneFeature"; break;
|
|
case GO_FEATURE_DATA_UNKNOWN: output = "UnknownFeature"; break;
|
|
default: return kERROR_PARAMETER;
|
|
}
|
|
|
|
strncpy(featureDataType, output, capacity - 1);
|
|
featureDataType[capacity - 1] = 0;
|
|
|
|
return kOK;
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceEdgeEdgeLine)
|
|
kAddVMethod(GoSurfaceEdgeEdgeLine, GoFeature, VInit)
|
|
//kAddVMethod(GoSurfaceEdgeEdgeLine, GoFeature, VRead)
|
|
//kAddVMethod(GoSurfaceEdgeEdgeLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceEdgeEdgeLine_VInit(GoSurfaceEdgeEdgeLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_EDGE_EDGE_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
/*
|
|
GoFx(kStatus) GoSurfaceEdgeEdgeLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml,item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEdgeEdgeLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
*/
|
|
kBeginClassEx(Go, GoSurfaceEdgeCenterPoint)
|
|
kAddVMethod(GoSurfaceEdgeCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceEdgeCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceEdgeCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceEdgeCenterPoint_VInit(GoSurfaceEdgeCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_EDGE_EDGE_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEdgeCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEdgeCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceBoundingBoxCenterPoint)
|
|
kAddVMethod(GoSurfaceBoundingBoxCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceBoundingBoxCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceBoundingBoxCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxCenterPoint_VInit(GoSurfaceBoundingBoxCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_BOUNDING_BOX_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceBoundingBoxAxisLine)
|
|
kAddVMethod(GoSurfaceBoundingBoxAxisLine, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceBoundingBoxAxisLine, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceBoundingBoxAxisLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxAxisLine_VInit(GoSurfaceBoundingBoxAxisLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_BOUNDING_BOX_AXIS_LINE, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxAxisLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceBoundingBoxAxisLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceCountersunkHoleCenterPoint)
|
|
kAddVMethod(GoSurfaceCountersunkHoleCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceCountersunkHoleCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceCountersunkHoleCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceCountersunkHoleCenterPoint_VInit(GoSurfaceCountersunkHoleCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_COUNTERSUNKHOLE_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceCountersunkHoleCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceCountersunkHoleCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceDimensionCenterPoint)
|
|
kAddVMethod(GoSurfaceDimensionCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceDimensionCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceDimensionCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceDimensionCenterPoint_VInit(GoSurfaceDimensionCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_DIMENSION_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceDimensionCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceDimensionCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceEllipseCenterPoint)
|
|
kAddVMethod(GoSurfaceEllipseCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceEllipseCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceEllipseCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus)GoSurfaceEllipseCenterPoint_VInit(GoSurfaceEllipseCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_ELLIPSE_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceEllipseMajorAxisLine)
|
|
kAddVMethod(GoSurfaceEllipseMajorAxisLine, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceEllipseMajorAxisLine, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceEllipseMajorAxisLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMajorAxisLine_VInit(GoSurfaceEllipseMajorAxisLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_ELLIPSE_MAJOR_AXIS_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMajorAxisLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMajorAxisLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceEllipseMinorAxisLine)
|
|
kAddVMethod(GoSurfaceEllipseMinorAxisLine, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceEllipseMinorAxisLine, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceEllipseMinorAxisLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMinorAxisLine_VInit(GoSurfaceEllipseMinorAxisLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_ELLIPSE_MINOR_AXIS_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMinorAxisLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceEllipseMinorAxisLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceHoleCenterPoint)
|
|
kAddVMethod(GoSurfaceHoleCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceHoleCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceHoleCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceHoleCenterPoint_VInit(GoSurfaceHoleCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_HOLE_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceHoleCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceHoleCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceOpeningCenterPoint)
|
|
kAddVMethod(GoSurfaceOpeningCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceOpeningCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceOpeningCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceOpeningCenterPoint_VInit(GoSurfaceOpeningCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_OPENING_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceOpeningCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceOpeningCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoSurfacePlanePlane)
|
|
kAddVMethod(GoSurfacePlanePlane, GoFeature, VInit)
|
|
kAddVMethod(GoSurfacePlanePlane, GoFeature, VRead)
|
|
kAddVMethod(GoSurfacePlanePlane, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfacePlanePlane_VInit(GoSurfacePlanePlane feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_PLANE_PLANE, sensor, srcTool, GO_FEATURE_DATA_PLANE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfacePlanePlane_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfacePlanePlane_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoSurfacePositionPoint)
|
|
kAddVMethod(GoSurfacePositionPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfacePositionPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfacePositionPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfacePositionPoint_VInit(GoSurfacePositionPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_POSITION_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfacePositionPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfacePositionPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoSurfaceStudTipPoint)
|
|
kAddVMethod(GoSurfaceStudTipPoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceStudTipPoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceStudTipPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceStudTipPoint_VInit(GoSurfaceStudTipPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_STUD_TIP_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceStudTipPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceStudTipPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoSurfaceStudBasePoint)
|
|
kAddVMethod(GoSurfaceStudBasePoint, GoFeature, VInit)
|
|
kAddVMethod(GoSurfaceStudBasePoint, GoFeature, VRead)
|
|
kAddVMethod(GoSurfaceStudBasePoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoSurfaceStudBasePoint_VInit(GoSurfaceStudBasePoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_SURFACE_STUD_BASE_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceStudBasePoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoSurfaceStudBasePoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfilePositionPoint)
|
|
kAddVMethod(GoProfilePositionPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfilePositionPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfilePositionPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfilePositionPoint_VInit(GoProfilePositionPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_POSITION_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePositionPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePositionPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileLineLine)
|
|
kAddVMethod(GoProfileLineLine, GoFeature, VInit)
|
|
kAddVMethod(GoProfileLineLine, GoFeature, VRead)
|
|
kAddVMethod(GoProfileLineLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileLineLine_VInit(GoProfileLineLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_LINE_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileLineMinErrorPoint)
|
|
kAddVMethod(GoProfileLineMinErrorPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileLineMinErrorPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileLineMinErrorPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileLineMinErrorPoint_VInit(GoProfileLineMinErrorPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_LINE_MIN_ERROR_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineMinErrorPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineMinErrorPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfileLineMaxErrorPoint)
|
|
kAddVMethod(GoProfileLineMaxErrorPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileLineMaxErrorPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileLineMaxErrorPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileLineMaxErrorPoint_VInit(GoProfileLineMaxErrorPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_LINE_MAX_ERROR_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineMaxErrorPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileLineMaxErrorPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfileIntersectIntersectPoint)
|
|
kAddVMethod(GoProfileIntersectIntersectPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileIntersectIntersectPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileIntersectIntersectPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileIntersectIntersectPoint_VInit(GoProfileIntersectIntersectPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_INTERSECT_INTERSECT_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectIntersectPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectIntersectPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileIntersectLine)
|
|
kAddVMethod(GoProfileIntersectLine, GoFeature, VInit)
|
|
kAddVMethod(GoProfileIntersectLine, GoFeature, VRead)
|
|
kAddVMethod(GoProfileIntersectLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileIntersectLine_VInit(GoProfileIntersectLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_INTERSECT_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileIntersectBaseLine)
|
|
kAddVMethod(GoProfileIntersectBaseLine, GoFeature, VInit)
|
|
kAddVMethod(GoProfileIntersectBaseLine, GoFeature, VRead)
|
|
kAddVMethod(GoProfileIntersectBaseLine, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileIntersectBaseLine_VInit(GoProfileIntersectBaseLine feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_INTERSECT_BASE_LINE, sensor, srcTool, GO_FEATURE_DATA_LINE, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectBaseLine_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileIntersectBaseLine_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileBoundingBoxCornerPoint)
|
|
kAddVMethod(GoProfileBoundingBoxCornerPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileBoundingBoxCornerPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileBoundingBoxCornerPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCornerPoint_VInit(GoProfileBoundingBoxCornerPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_BOUNDING_BOX_CORNER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCornerPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCornerPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileBoundingBoxCenterPoint)
|
|
kAddVMethod(GoProfileBoundingBoxCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileBoundingBoxCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileBoundingBoxCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCenterPoint_VInit(GoProfileBoundingBoxCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_BOUNDING_BOX_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileBoundingBoxCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileAreaCenterPoint)
|
|
kAddVMethod(GoProfileAreaCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileAreaCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileAreaCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileAreaCenterPoint_VInit(GoProfileAreaCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_AREA_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileAreaCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileAreaCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileCircleCenterPoint)
|
|
kAddVMethod(GoProfileCircleCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileCircleCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileCircleCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileCircleCenterPoint_VInit(GoProfileCircleCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_CIRCLE_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileCircleCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileCircleCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileDimensionCenterPoint)
|
|
kAddVMethod(GoProfileDimensionCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileDimensionCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileDimensionCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileDimensionCenterPoint_VInit(GoProfileDimensionCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_DIMENSION_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileDimensionCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileDimensionCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfilePanelLeftGapPoint)
|
|
kAddVMethod(GoProfilePanelLeftGapPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfilePanelLeftGapPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfilePanelLeftGapPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftGapPoint_VInit(GoProfilePanelLeftGapPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_PANEL_LEFT_GAP_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftGapPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftGapPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfilePanelLeftFlushPoint)
|
|
kAddVMethod(GoProfilePanelLeftFlushPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfilePanelLeftFlushPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfilePanelLeftFlushPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftFlushPoint_VInit(GoProfilePanelLeftFlushPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_PANEL_LEFT_FLUSH_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftFlushPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelLeftFlushPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfilePanelRightGapPoint)
|
|
kAddVMethod(GoProfilePanelRightGapPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfilePanelRightGapPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfilePanelRightGapPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfilePanelRightGapPoint_VInit(GoProfilePanelRightGapPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_PANEL_RIGHT_GAP_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelRightGapPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelRightGapPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfilePanelRightFlushPoint)
|
|
kAddVMethod(GoProfilePanelRightFlushPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfilePanelRightFlushPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfilePanelRightFlushPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfilePanelRightFlushPoint_VInit(GoProfilePanelRightFlushPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_PANEL_RIGHT_FLUSH_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelRightFlushPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfilePanelRightFlushPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileRoundCornerPoint)
|
|
kAddVMethod(GoProfileRoundCornerPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileRoundCornerPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileRoundCornerPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerPoint_VInit(GoProfileRoundCornerPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_ROUND_CORNER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
kBeginClassEx(Go, GoProfileRoundCornerEdgePoint)
|
|
kAddVMethod(GoProfileRoundCornerEdgePoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileRoundCornerEdgePoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileRoundCornerEdgePoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerEdgePoint_VInit(GoProfileRoundCornerEdgePoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_ROUND_CORNER_EDGE_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerEdgePoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerEdgePoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|
|
|
|
|
|
kBeginClassEx(Go, GoProfileRoundCornerCenterPoint)
|
|
kAddVMethod(GoProfileRoundCornerCenterPoint, GoFeature, VInit)
|
|
kAddVMethod(GoProfileRoundCornerCenterPoint, GoFeature, VRead)
|
|
kAddVMethod(GoProfileRoundCornerCenterPoint, GoFeature, VWrite)
|
|
kEndClassEx()
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerCenterPoint_VInit(GoProfileRoundCornerCenterPoint feature, kType type, kObject sensor, kObject srcTool, kAlloc alloc)
|
|
{
|
|
kCheck(GoFeature_Init(feature, type, GO_FEATURE_PROFILE_ROUND_CORNER_CENTER_POINT, sensor, srcTool, GO_FEATURE_DATA_POINT, alloc));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerCenterPoint_VRead(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VRead(feature, xml, item);
|
|
}
|
|
|
|
GoFx(kStatus) GoProfileRoundCornerCenterPoint_VWrite(GoFeature feature, kXml xml, kXmlItem item)
|
|
{
|
|
return GoFeature_VWrite(feature, xml, item);
|
|
}
|