/*================================================================*\ FILE: UtilCable.c PURPOSE: Functions to manage cabling HISTORY: 24-Aug-98 I-01-17 Pavel $$1 Created. 28-Aug-98 I-01-17 Alexey $$2 Cast int error values to ProError when calling to TEST_CALL_REPORT. It allows to avoid C++ compiler error on ALPHA_UNIX 14-Sep-98 I-01-19 Pavel $$3 Modified ProCblCableLogicalEndsGet. 29-Dec-98 I-01-28 Alexey $$4 Add -4 as valid return value to TEST_CALL_REPORT for some ProCbl funcs 30-Dec-98 I-01-28 Alexey $$5 Don't use TRUE, it's not defined on sgi_elf2 03-Aug-00 J-01-13 Scott $$6 Set the bundle name correctly from ProCblBundleCreate \*=================================================================*/ #include "UtilCable.h" #include "UtilString.h" #include "TestError.h" /*---------------------------------------------------------------------------*\ Functions to manage wires, cables and bundless \*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*\ Function : ProCblWireHarnessesGet Purpose : Retrieves pointers to the harnesses in the specified assembly that contain the specified wire. \*---------------------------------------------------------------------------*/ ProError ProCblCableHarnessesGet ( ProCblCable *p_cable, /* In: wire handle */ ProCblHarness **p_harnesses, /* Out: ProArray of harnesses user must free memory by ProArrayFree */ int *har_num) /* Out: harness number */ { int error; int i; Prohandle *p_har_arr; ProName name; if (p_cable == NULL || p_harnesses == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_wire_harnesses ((Prohandle)p_cable->p_owner->owner, p_cable->name, &p_har_arr); TEST_CALL_REPORT("procbl_get_wire_harnesses", "ProCblWireHarnessesGet", (ProError)error, 0); if (error == -1) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (error, sizeof (ProCblHarness), 1, (ProArray*)p_harnesses); for (i = 0; i < error; i++) { ProMdlNameGet ((ProMdl)p_harnesses[i], name); ProCblHarnessInit ((ProPart)p_har_arr[i], name, (ProAssembly)p_cable->p_owner->owner, &(*p_harnesses)[i]); } *har_num = error; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableLengthGet Purpose : Retrieves the length of the specified wire \*---------------------------------------------------------------------------*/ ProError ProCblCableLengthGet ( ProCblCable *p_wire, /* In: wire handle */ double *p_length) /* Out: wire length */ { int error; if (p_wire == NULL || p_length == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_wire_length ((Prohandle)p_wire->p_owner->harness, p_wire->name, p_length); TEST_CALL_REPORT("procbl_get_wire_length", "ProCblWireLengthGet", (ProError)error, 0); if (!error) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableInit Purpose : Initialize cable structure \*---------------------------------------------------------------------------*/ ProError ProCblCableInit ( int id, /* In: cable's id */ ProName name, /* In: cable's name */ ProCblHarness *p_owner, /* In: cable's owner */ ProCblCable *p_cable) /* Out:cable's handle to init*/ { int error = 0; if (p_cable == NULL || (id == -1 && name == NULL)) return (PRO_TK_BAD_INPUTS); if (id == -1) { error = procbl_get_cable_id((Prohandle)p_owner->harness, name, &p_cable->id); TEST_CALL_REPORT("procbl_get_cable_id", "ProCblCableInit", (ProError)error, 0); } else p_cable->id = id; if (name == NULL) { error = procbl_get_cable_name((Prohandle)p_owner->harness, id, p_cable->name); TEST_CALL_REPORT("procbl_get_cable_name", "ProCblCableInit", (ProError)error, 0); } else ProUtilWstrcpy (p_cable->name, name); p_cable->p_owner = p_owner; return (error ==0 ? PRO_TK_NO_ERROR : PRO_TK_GENERAL_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableNameGet Purpose : Retrieves cable name \*---------------------------------------------------------------------------*/ ProError ProCblCableNameGet ( ProCblCable *p_cable, /* In: cable's handle*/ ProName name) /* Out:cable's name */ { if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); ProUtilWstrcpy(name, p_cable->name); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableIdGet Purpose : Retrieves cable id \*---------------------------------------------------------------------------*/ ProError ProCblCableIdGet ( ProCblCable *p_cable, /* In: cable's handle*/ int *p_id) /* Out:cable's id */ { if (p_cable == NULL || p_id == NULL) return (PRO_TK_BAD_INPUTS); *p_id = p_cable->id; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableTypeGet Purpose : Retrieves cable type \*---------------------------------------------------------------------------*/ ProError ProCblCableTypeGet ( ProCblCable *p_cable, /* in: cable handle */ Procbl_cable_type *p_type) /* Out: cable type */ { int error; if (p_cable == NULL || p_type == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_subtype ((Prohandle)(p_cable->p_owner)->harness, p_cable->name, p_type); TEST_CALL_REPORT("procbl_get_cable_subtype", "Procbl_cable_typeGet", (ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableCreate Purpose : Creates new cable or wire in specified harness \*---------------------------------------------------------------------------*/ ProError ProCblCableCreate ( ProCblHarness *p_harness, /* In: harness's handle*/ ProCblSpool *p_spool, /* In: spool's name */ ProName cable_name, /* In: cable's name */ ProCblCable *p_cable) /* Out:Handle of new cable*/ { int error; ProError status; int cable_id; ProName w_spool_name; if (p_harness == NULL || p_cable == NULL) return (PRO_TK_BAD_INPUTS); status = ProCblSpoolNameGet(p_spool, w_spool_name); TEST_CALL_REPORT("ProCblSpoolNameGet", "ProCblCableCreate", status, status != PRO_TK_NO_ERROR); error = procbl_create_cable ((Prohandle)p_harness->owner, (Prohandle)p_harness->harness, w_spool_name, cable_name, &cable_id); TEST_CALL_REPORT("procbl_create_cable", "ProCblCableCreate", (ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProCblCableInit (cable_id, cable_name, p_harness, p_cable); return (status); } /*---------------------------------------------------------------------------*\ Function : ProCblBundleCreate Purpose : Creates new bundle in specified harness \*---------------------------------------------------------------------------*/ ProError ProCblBundleCreate ( ProCblHarness *p_harness, /* In: harness's handle*/ ProCblSpool *p_spool, /* In: spool's name */ ProName bundle_name, /* In: bundle's name */ int cable_num, /* In: cable num */ ProCblCable *p_cables, /* In: the array of cables to add */ int bundle_type, /* In: TRUE=flat, FALSE=round */ ProCblBundle *p_bundle) /* Out:Handle of new bundle*/ { ProError status; int error; int cable_id, i; PRODEV_Name *cable_names; ProName w_spool_name; if (p_harness == NULL || p_cables == NULL || p_bundle == NULL) return (PRO_TK_BAD_INPUTS); status = ProCblSpoolNameGet(p_spool, w_spool_name); TEST_CALL_REPORT("ProCblSpoolNameGet", "ProCblBundleCreate", status, status != PRO_TK_NO_ERROR); status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1, (ProArray*)&cable_names); for (i = 0; i < cable_num; i++) status = ProArrayObjectAdd ((ProArray*)&cable_names, PRO_VALUE_UNUSED, 1, p_cables[i].name); error = procbl_create_bundle ((Prohandle)p_harness->owner, (Prohandle)p_harness->harness, w_spool_name, bundle_name, bundle_type, cable_num, cable_names, &cable_id); TEST_CALL_REPORT("procbl_create_bundle", "ProCblBundleCreate", (ProError)error, 0); /* procbl_create_bundle now sets the name to include '*' (as it should have all along). Make sure that we have the right name for the ProCblCable structure. */ error = procbl_get_cable_name ((Prohandle)p_harness->harness, cable_id, bundle_name); TEST_CALL_REPORT("procbl_get_cable_name", "ProCblBundleCreate", (ProError)error, 0); status = ProArrayFree ((ProArray*)&cable_names); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProCblCableInit (cable_id, bundle_name, p_harness, (ProCblCable*)p_bundle); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblBundleCablesGet Purpose : Retrieves one parameter for the specified cable \*---------------------------------------------------------------------------*/ ProError ProCblBundleCablesGet ( ProCblBundle *p_bundle, /* In: bundle handle */ int level, /* In: level: -1 collect all cables 1 retrieve all cables included in the input bundle 2 retrieve all cables included in the first level bundle */ ProCblCable **p_cables, /* Out: ProArray of cables handles User must free mem using ProArrayFree*/ int *p_n_cables) /* Out: cables number */ { int error, i, cable_id; PRODEV_Name *p_cables_names; if (p_bundle == NULL || p_cables == NULL || p_n_cables == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_bundle_cables ((Prohandle)(p_bundle->p_owner)->harness, p_bundle->name, level, &p_cables_names, p_n_cables); TEST_CALL_REPORT("procbl_get_bundle_cables", "ProCblBundleCablesGet", (ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*p_n_cables, sizeof (ProCblCable), 1, (ProArray*)p_cables); for (i = 0; i < *p_n_cables; i++) { error = procbl_get_cable_id ((Prohandle)(p_bundle->p_owner)->harness, p_cables_names[i], &cable_id); TEST_CALL_REPORT("procbl_get_cable_id", "ProCblBundleCablesGet", (ProError)error, 0); if (error != PRODEV_NO_ERROR) break; ProCblCableInit (cable_id, p_cables_names[i], p_bundle->p_owner, &(*p_cables)[i]); } if (error != PRODEV_NO_ERROR) { ProArrayFree ((ProArray*)p_cables); return (PRO_TK_GENERAL_ERROR); } return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableParameterGet Purpose : Retrieves one parameter for the specified cable \*---------------------------------------------------------------------------*/ ProError ProCblCableParameterGet ( ProCblCable *p_cable, /* In: cable's handle*/ ProName param_name, /* In: parameter's name */ ProCblParameterInfo *p_param_info) /* Out: parameter's info */ { int error; if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_param ((Prohandle)((p_cable->p_owner)->owner), (Prohandle)((p_cable->p_owner)->harness), p_cable->name, param_name, p_param_info); TEST_CALL_REPORT("procbl_get_cable_param", "ProCblCableParameterGet", (ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableParameterDelete Purpose : Deletes one parameter for specified cable \*---------------------------------------------------------------------------*/ ProError ProCblCableParameterDelete ( ProCblCable *p_cable, /* In: cable's handle*/ ProName param_name) /* In: parameter's name*/ { int error; if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_delete_cable_param ((Prohandle)((p_cable->p_owner)->owner), (Prohandle)((p_cable->p_owner)->harness), p_cable->name, param_name); TEST_CALL_REPORT("procbl_delete_cable_param", "ProCblCableParameterDelete", (ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_BAD_INPUTS); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableParametersGet Purpose : Retrieves the parameters, including all values associated with multivalued parameters, for the specified cable \*---------------------------------------------------------------------------*/ ProError ProCblCableParametersGet ( ProCblCable *p_cable, /* In: cable's handle*/ ProCblParameterInfo **p_params_info, /* Out: ProArray of parameters */ int *param_num) /* Out: parameter's number*/ { int error; if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_params ((Prohandle)((p_cable->p_owner)->owner), (Prohandle)((p_cable->p_owner)->harness), p_cable->name, (Pro_parameter_info**)p_params_info); TEST_CALL_REPORT("procbl_get_cable_params", "ProCblCableParametersGet", (ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *param_num = error; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableParametersSet Purpose : Sets parameters for the specified cable \*---------------------------------------------------------------------------*/ ProError ProCblCableParametersSet ( ProCblCable *p_cable, /* In: cable's handle*/ ProCblParameterInfo *p_params_info, /* In: array of parameters */ int param_num) /* In: parameter's number*/ { int error; if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_set_cable_params ((Prohandle)((p_cable->p_owner)->owner), (Prohandle)((p_cable->p_owner)->harness), p_cable->name, param_num, (Pro_parameter_info*) p_params_info); TEST_CALL_REPORT("procbl_set_cable_params", "ProCblCableParametersSet", (ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableLogicalEndsGet Purpose : Retrieves logical ends of specified cable \*---------------------------------------------------------------------------*/ ProError ProCblCableLogicalEndsGet ( ProCblCable *p_cable, /* In: cable's handle*/ Select3d ends[2]) /* Out: The entry ports (user must allocate memory) */ { ProError status; int error; Select3d e_select_3d[2]; if (p_cable == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_logical_ends ( (Prohandle)((p_cable->p_owner)->owner), (Prohandle)((p_cable->p_owner)->harness), p_cable->name, e_select_3d); TEST_CALL_REPORT("procbl_get_cable_logical_ends", "ProCblCableLogicalEndsGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); ends[0] = e_select_3d[0]; ends[1] = e_select_3d[1]; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCablesFromLogicalCreate Purpose : Creates cables from logical If corresponding spools are not created they are also created by this func. \*---------------------------------------------------------------------------*/ ProError ProCblCablesFromLogicalCreate ( ProCblHarness *p_harness, /* In: harness's handle*/ int cable_num, /* In: the number of cables to create */ ProName *p_cable_names) /* In: cables names */ { ProError status; int error, i; PRODEV_Name *prodev_names; if (p_harness == NULL || p_cable_names == NULL) return (PRO_TK_BAD_INPUTS); status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1, (ProArray*)&prodev_names); for (i = 0; i < cable_num; i++) status = ProArrayObjectAdd ((ProArray*)&prodev_names, PRO_VALUE_UNUSED, 1, p_cable_names[i]); error = procbl_create_cables_from_logical ( (Prohandle)(p_harness->owner), (Prohandle)(p_harness->harness), cable_num, prodev_names); TEST_CALL_REPORT("procbl_create_cables_from_logical", "ProCblCablesFromLogicalCreate",(ProError)error, 0); status = ProArrayFree ((ProArray*)&prodev_names); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCablesFromLogicalGet Purpose : Returns list of imported but not created cables \*---------------------------------------------------------------------------*/ ProError ProCblCablesFromLogicalGet ( ProAssembly asm_mdl, /* In: assembly's handle*/ ProName **p_cable_names, /* Out: ProArray of cable names */ int *cable_num) /* Out: cables number */ { ProError status; int error, i; PRODEV_Name *prodev_names; if (asm_mdl == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cables_from_logical ((Prohandle)asm_mdl, &prodev_names); TEST_CALL_REPORT("procbl_get_cables_from_logical", "ProCblCablesFromLogicalGet",(ProError)error, 0); if( error == PRODEV_INVALID_INPUT ) return (PRO_TK_E_NOT_FOUND); if ( error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *cable_num = error; status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_cable_names); if (status != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); for (i = 0; i < *cable_num; i++) status = ProArrayObjectAdd ((ProArray*)p_cable_names, PRO_VALUE_UNUSED, 1, prodev_names[i]); /* status = ProArrayFree ((ProArray*)&prodev_names); */ return (status); } /*---------------------------------------------------------------------------*\ Function : ProCblCableLocationsGet Purpose : Finds the locations for the specified cable or wire \*---------------------------------------------------------------------------*/ ProError ProCblCableLocationsGet ( ProCblCable *p_cable, /* In: cable handle */ int **p_location_array, /* Out: ProArray of locations ids */ int *n_locations) /* Out: Locations number */ { int error, i; int *p_locations; if (p_cable == NULL || p_location_array == NULL || n_locations == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_locations ((Prohandle)(p_cable->p_owner)->owner, (Prohandle)(p_cable->p_owner)->harness, p_cable->name, &p_locations, n_locations); TEST_CALL_REPORT("procbl_get_cable_locations", "ProCblCableLocationsGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*n_locations, sizeof (int), 1, (ProArray*)p_location_array); for (i = 0; i < *n_locations; i++) (*p_location_array)[i] = p_locations[i]; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblLocationCablesGet Purpose : Find cables at the specified location \*---------------------------------------------------------------------------*/ ProError ProCblLocationCablesGet ( ProCblHarness *p_harness, /* In: harness handle */ int loc_id, /* In: location id */ ProCblCable **p_cables, /* Out: ProArray of cables handles*/ int *p_n_cables) /* Out: cables num */ { int error, i, cable_id; PRODEV_Name *p_cable_names; if (p_cables == NULL || p_harness == NULL || p_n_cables == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_location_cables ((Prohandle)p_harness->harness, loc_id, &p_cable_names, p_n_cables); TEST_CALL_REPORT("procbl_get_location_cables", "ProCblLocationCablesGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*p_n_cables, sizeof (ProCblCable), 1, (ProArray*)p_cables); for (i = 0; i < *p_n_cables; i++) { error = procbl_get_cable_id ((Prohandle)p_harness->harness, p_cable_names[i], &cable_id); TEST_CALL_REPORT("procbl_get_cable_id", "ProCblLocationCablesGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) break; ProCblCableInit (cable_id, p_cable_names[i], p_harness, &(*p_cables)[i]); } if (error != PRODEV_NO_ERROR) { ProArrayFree ((ProArray*)p_cables); return (PRO_TK_GENERAL_ERROR); } return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableGeomGet Purpose : Retrieves cable geometry \*---------------------------------------------------------------------------*/ ProError ProCblCableGeomGet ( ProCblCable *p_cable, /* In: cable handle */ ProCblCableGeom **p_geom) /* Out: cable geom */ /* The function allocates the memory for this argument, and reuses it on subsequent calls. You should not free the memory or keep a pointer to it.*/ { int error; if (p_cable == NULL || p_geom == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_cable_geom ((Prohandle)(p_cable->p_owner)->harness, p_cable->name, p_geom); TEST_CALL_REPORT("procbl_get_cable_geom ", "ProCblCableGeomGet",(ProError)error, 0); if (error != 0) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblCableClearance Purpose : Determines the clearance of the specified cable, and reports if interference was found \*---------------------------------------------------------------------------*/ ProError ProCblCableClearance ( ProSelection sel1, /* In: first selection */ ProSelection sel2, /* In: second selection */ ProBoolean *interference, /* Out: interference */ ProPoint3d pnt_arr[2]) /* Out: The coordinates of the closest points*/ { int error; int interf; if (interference == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_cable_clearance (sel1, sel2, &interf, pnt_arr); TEST_CALL_REPORT("procbl_cable_clearance", "ProCblCableClearance",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); if (interf == 1) *interference = PRO_B_FALSE; else *interference = PRO_B_TRUE; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Functions to manage connectors \*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*\ Function : ProCblConnectorInit Purpose : Initializes connector structure \*---------------------------------------------------------------------------*/ ProError ProCblConnectorInit ( ProAsmcomppath *path, /* In : Assembly component path */ ProCblConnector *p_connector) /* Out: pointer to connector structure to initialize */ { int i, j, ierr, **p_comp_id_tab, *p_table_num, num_connectors = 0; if (!path) return (PRO_TK_BAD_INPUTS); *p_connector = *(ProCblConnector*)path; ierr = procbl_get_assy_connectors((Prohandle)path->owner, &p_comp_id_tab, &p_table_num, &num_connectors); TEST_CALL_REPORT("procbl_get_assy_connectors", "ProCblConnectorInit", (ProError)ierr, 0); if (ierr != PRODEV_NO_ERROR) return (PRO_TK_E_NOT_FOUND); for (i=0; icomp_id_table[j] != p_comp_id_tab[i][j]) break; if (j>=p_table_num[i]) break; } ierr = pro_release_memb_id_tab(p_comp_id_tab); TEST_CALL_REPORT("pro_release_memb_id_tab", "ProCblConnectorInit", (ProError)ierr, 0); if (iowner, p_connector->table_num, p_connector->comp_id_table, w_param_name, p_param); TEST_CALL_REPORT("procbl_get_connector_param", "ProCblConnectorParameterGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_BAD_INPUTS); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorParameterDelete Purpose : Deletes parameter of specified connector \*---------------------------------------------------------------------------*/ ProError ProCblConnectorParameterDelete ( ProCblConnector *p_connector, /* In : Connector's handle*/ ProName w_param_name) /* In : Parameter name */ { int error; if (p_connector == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_delete_connector_param ((Prohandle)p_connector->owner, p_connector->table_num, p_connector->comp_id_table, w_param_name); TEST_CALL_REPORT("procbl_delete_connector_param ", "ProCblConnectorParameterDelete",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorParametersGet Purpose : Retrives parameters of specified connector \*---------------------------------------------------------------------------*/ ProError ProCblConnectorParametersGet ( ProCblConnector *p_connector,/* In : connector's handle*/ ProCblParameterInfo **p_param, /* Out: ProArray of params*/ int *param_num) /* Out: Number of parameters */ { int error; if (p_connector == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_connector_params ((Prohandle)p_connector->owner, p_connector->table_num, p_connector->comp_id_table, p_param); TEST_CALL_REPORT("procbl_get_connector_params", "ProCblConnectorParametersGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT || error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *param_num = error; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorParametersSet Purpose : Sets parameter of specified connector \*---------------------------------------------------------------------------*/ ProError ProCblConnectorParametersSet ( ProCblConnector *p_connector, /* In : connector's handle*/ ProCblParameterInfo *p_param, /* In : handles of parameter's*/ int n_param) /* In : parameter's number */ { int error; if (p_connector == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_set_connector_params ((Prohandle)p_connector->owner, p_connector->table_num, p_connector->comp_id_table, n_param, p_param); TEST_CALL_REPORT("procbl_set_connector_params ", "ProCblConnectorParametersSet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorFromLogical Purpose : Returns list of imported, but not designated connectors \*---------------------------------------------------------------------------*/ ProError ProCblConnectorFromLogical ( ProAssembly asm_mdl, /* In : The cabling assembly's handle */ ProName **p_w_name, /* Out: list of log. con. ProArray, to free call ProArrayFree */ int *con_num) /* Out: number of connectores */ { ProError status; int error, i; PRODEV_Name *con_names; if (asm_mdl == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_connectors_from_logical ((Prohandle)asm_mdl, &con_names); TEST_CALL_REPORT("procbl_get_connectors_from_logical", "ProCblConnectorFromLogical",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *con_num = error; status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_w_name); for (i = 0; i < *con_num; i++) status = ProArrayObjectAdd ((ProArray*)p_w_name, PRO_VALUE_UNUSED, 1, con_names[i]); status = ProArrayFree ((ProArray*)&con_names); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblAssemblyConnectorsGet Purpose : Collect all designated connectors \*---------------------------------------------------------------------------*/ ProError ProCblAssemblyConnectorsGet ( ProAssembly assy, /* In: The handle of cabling's assembly. */ ProCblConnector **p_cons, /* Out: ProArray of connectors if successfull, to free call ProArrayFree */ int *num_cons)/* Out: Number of retrieved connectors*/ { int error, i, j, **p_ids_tab_array, *p_nums_array; if (assy == NULL || p_cons == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_assy_connectors ((Prohandle)assy, &p_ids_tab_array, &p_nums_array, num_cons); TEST_CALL_REPORT("procbl_get_assy_connectors ", "ProCblAssemblyConnectorsGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc( *num_cons, sizeof(ProCblConnector), 1, (ProArray*)p_cons); for( i=0; i<*num_cons; i++) { (*p_cons)[i].owner = assy; (*p_cons)[i].table_num = p_nums_array[i]; for( j=0; jowner, p_connector->comp_id_table, p_connector->table_num, name); TEST_CALL_REPORT("procbl_designate_connector", "ProCblConnectorDesignate",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorUndesignate Purpose : Undesignate specified connector \*---------------------------------------------------------------------------*/ ProError ProCblConnectorUndesignate ( ProCblConnector *p_connector) /* In: connector to undesignate */ { int error; if (p_connector == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_undesignate_connector ((Prohandle)p_connector->owner, p_connector->comp_id_table, p_connector->table_num); TEST_CALL_REPORT("procbl_undesignate_connector", "ProCblConnectorUndesignate",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblConnectorEntryPortsGet Purpose : Retrieves the entry ports for the specified connector \*---------------------------------------------------------------------------*/ ProError ProCblConnectorEntryPortsGet ( ProCblConnector *p_connector, /* In: connector handle */ int **p_csys_id_array, /* Out: ProArray of Csys ids */ int *p_num_csys) /* Out: csys number */ { int error; int *p_id_array, i; if (p_connector == NULL || p_csys_id_array == NULL || p_num_csys == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_connector_entry_ports ((Prohandle)p_connector->owner, p_connector->comp_id_table, p_connector->table_num, &p_id_array, p_num_csys); TEST_CALL_REPORT("procbl_get_connector_entry_ports", "ProCblConnectorEntryPortsGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*p_num_csys, sizeof (int), 1, (ProArray*)p_csys_id_array); for (i = 0; i <*p_num_csys; i++) (*p_csys_id_array)[i] = p_id_array[i]; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Functions to manage harnesses. \*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*\ Function : ProCblAssemblyHarnessesGet Purpose : Retrive harnesses \*---------------------------------------------------------------------------*/ ProError ProCblAssemblyHarnessesGet ( ProAssembly asm_mdl, /* In : assembly's handle */ ProCblHarness **p_harness, /* Out: array of harness handles to fill. User must free this with ProArrayFree */ int *num_harness) /* Out: Number of harness*/ { int error, i; ProError status; ProName name; Prohandle *p_handles; if (asm_mdl == NULL || p_harness == NULL || num_harness == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_assy_harnesses ((Prohandle)asm_mdl, (Prohandle**)&p_handles, num_harness); TEST_CALL_REPORT("procbl_get_assy_harnesses", "ProCblAssemblyHarnessesGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProArrayAlloc (*num_harness, sizeof(ProCblHarness), 1, (ProArray*)p_harness); for( i=0; i<*num_harness; i++) { ProMdlNameGet ((ProMdl)p_handles[i], name); status = ProCblHarnessInit ((ProPart)p_handles[i], name, asm_mdl, &(*p_harness)[i]); } return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessInit Purpose : Initialize harness structure \*---------------------------------------------------------------------------*/ ProError ProCblHarnessInit ( ProPart harness_mdl, /* In: harness part */ ProName name, /* In: harness name */ ProAssembly asm_mdl, /* In: harness owner */ ProCblHarness *p_harness) /* Out: handle of harness to init */ { if (p_harness == NULL) return (PRO_TK_BAD_INPUTS); p_harness->harness = harness_mdl; ProUtilWstrcpy (p_harness->name, name); p_harness->owner = asm_mdl; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessCreate Purpose : Creates new harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessCreate ( ProAssembly asm_mdl, /* In : assembly's handle */ ProName w_name, /* In : harness name */ ProCblHarness *p_harness) /* Out: handle of harness to fill */ { ProError status; int error; ProPart harness_part; if (asm_mdl == NULL || p_harness == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_create_harness ((Prohandle)asm_mdl, w_name, (Prohandle*)&harness_part); TEST_CALL_REPORT("procbl_create_harness", "ProCblHarnessCreate",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProCblHarnessInit (harness_part, w_name, asm_mdl, p_harness); return (status); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessNameGet Purpose : Retrive the name of harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessNameGet ( ProCblHarness *p_harness, /* In : harness*/ ProName w_name) /* Out: harness name*/ { if (p_harness == NULL) return (PRO_TK_BAD_INPUTS); ProUtilWstrcpy (w_name, p_harness->name); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessCablesGet Purpose : Get cables from specified harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessCablesGet ( ProCblHarness *p_harness, /* In : harness*/ ProCblCable **p_cables, /* Out: ProArray of cables, (user must call ProArrayFree)*/ int *p_n_cables) /* Out: number of cables */ { int error, i, cable_id; PRODEV_Name *p_cables_names; if (p_harness == NULL || p_cables == NULL || p_n_cables == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_harness_cables ((Prohandle)p_harness->harness, &p_cables_names, p_n_cables); TEST_CALL_REPORT("procbl_get_harness_cables", "ProCblHarnessCablesGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*p_n_cables, sizeof (ProCblCable), 1, (ProArray*)p_cables); for (i = 0; i < *p_n_cables; i++) { error = procbl_get_cable_id ((Prohandle)p_harness->harness, p_cables_names[i], &cable_id); TEST_CALL_REPORT("procbl_get_cable_id", "ProCblHarnessCablesGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) break; ProCblCableInit (cable_id, p_cables_names[i], p_harness, &(*p_cables)[i]); } if (error != PRODEV_NO_ERROR) { ProArrayFree ((ProArray*)p_cables); return (PRO_TK_GENERAL_ERROR); } return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessLocationsGet Purpose : Finds the locations for the specified harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessLocationsGet ( ProCblHarness *p_harness, /* In: harness handle */ int **p_location_array, /* Out: ProArray of locations */ int *n_locations) /* Out: locations number */ { int error, i; int *p_locations; if (p_harness == NULL || p_location_array == NULL || n_locations == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_harness_locations ((Prohandle)p_harness->owner, (Prohandle)p_harness->harness, &p_locations, n_locations); TEST_CALL_REPORT("procbl_get_harness_locations", "ProCblHarnessLocationsGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProArrayAlloc (*n_locations, sizeof (int), 1, (ProArray*)p_location_array); for (i = 0; i < *n_locations; i++) (*p_location_array)[i] = p_locations[i]; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessLocationTypeGet Purpose : Retrieve location type of specified harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessLocationTypeGet ( ProCblHarness *p_harness, /* In: harness handle */ int location_id, /* In: location id */ ProCblLocationType *type) /*Out: location type */ { int error; if (p_harness == NULL || type == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_location_type ((Prohandle)p_harness->harness, location_id, type); TEST_CALL_REPORT("procbl_get_location_type", "ProCblHarnessLocationTypeGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblHarnessLocationPntGet Purpose : Retrieve location point of specified harness \*---------------------------------------------------------------------------*/ ProError ProCblHarnessLocationPntGet ( ProCblHarness *p_harness, /* In: harness handle */ int location_id, /* In: location id */ ProCblLocationPnt *pnt) /*Out: location point */ { int error; if (p_harness == NULL || pnt == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_location_pnt ((Prohandle)p_harness->harness, location_id, pnt); TEST_CALL_REPORT("procbl_get_location_pnt", "ProCblHarnessLocationPntGet",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Functions to manage spools. \*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*\ Function : ProCblAssemblySpoolsGet Purpose : Collect spools in specified assembly \*---------------------------------------------------------------------------*/ ProError ProCblAssemblySpoolsGet ( ProAssembly asm_mdl, /* In : assembly's handle*/ ProCblSpool **p_spool, /* Out: pointer on array of spool's handle's to init.Function allocate memory for this argument, use ProArrayFree to free it.*/ int *num_spools) /* Out: number of retrieved spools*/ { int error, i; ProError status; PRODEV_Name *spool_names; if (asm_mdl == NULL || p_spool == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_assy_spools ((Prohandle)asm_mdl, &spool_names); TEST_CALL_REPORT("procbl_get_assy_spools", "ProCblAssemblySpoolsGe",(ProError)error, 0); if(error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if(error == PRODEV_GENERAL_ERROR) return (PRO_TK_BAD_INPUTS); if (num_spools) *num_spools = error; status = ProArrayAlloc (error, sizeof(ProCblSpool), 1, (ProArray*)p_spool); for( i=0; iowner = asm_mdl; ProUtilWstrcpy (p_spool->name, w_name); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolNameGet Purpose : returns spool name \*---------------------------------------------------------------------------*/ ProError ProCblSpoolNameGet ( ProCblSpool *p_spool, /* In: handle of spool to init*/ ProName w_name) /* Out: spool name*/ { ProUtilWstrcpy(w_name, p_spool->name); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolCreate Purpose : Creates new spool \*---------------------------------------------------------------------------*/ ProError ProCblSpoolCreate ( ProAssembly assy, /* In : assembly's handle*/ ProName w_name, /* In : harness name*/ Procbl_cable_type cable_type, /* In : cable type */ Procbl_sheath_type sheath_type, /* In : bundle type */ ProCblSpool *p_spool) /* Out :user's memory */ { ProError status; int error; if (assy == NULL || p_spool == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_create_spool ((Prohandle)assy, w_name, cable_type, sheath_type); TEST_CALL_REPORT("procbl_create_spool", "ProCblSpoolCreate",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProCblSpoolInit (assy, w_name, p_spool); if (status != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolParametersGet Purpose : Retrieves parameters of specified spool \*---------------------------------------------------------------------------*/ ProError ProCblSpoolParametersGet ( ProCblSpool *p_spool, /* In : spool's handle*/ ProCblParameterInfo **p_param, /* Out: ProArray */ int *param_num) /* Out: params num */ { int error; if (p_spool == NULL || p_param == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_spool_params ((Prohandle)p_spool->owner, p_spool->name, p_param); TEST_CALL_REPORT("procbl_get_spool_params", "ProCblSpoolParametersGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *param_num = error; return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolParameterGet Purpose : Retrieves one parameter of specified spool \*---------------------------------------------------------------------------*/ ProError ProCblSpoolParameterGet ( ProCblSpool *p_spool, /* In : spool's handle*/ ProName w_param_name, /* In : parametr name */ ProCblParameterInfo *p_param) /* Out: user's memory */ { int error; if (p_spool == NULL || p_param == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_spool_param ((Prohandle)p_spool->owner, p_spool->name, w_param_name, p_param); TEST_CALL_REPORT("procbl_get_spool_param ", "ProCblSpoolParameterGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolParametersSet Purpose : Set parameters for specified spool \*---------------------------------------------------------------------------*/ ProError ProCblSpoolParametersSet ( ProCblSpool *p_spool,/* In : spool*/ ProCblParameterInfo *p_param,/* In : the array of parameters*/ int n_param)/* In : the number of parameters*/ { int error; if (p_spool == NULL || p_param == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_set_spool_params ((Prohandle)p_spool->owner, p_spool->name, n_param, p_param); TEST_CALL_REPORT("procbl_set_spool_params", "ProCblSpoolParametersSet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolParameterDelete Purpose : Deletes parameter in specified spool \*---------------------------------------------------------------------------*/ ProError ProCblSpoolParameterDelete ( ProCblSpool *p_spool, /* In : spool*/ ProName param_name) /* In : param name*/ { int error; if (p_spool == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_delete_spool_param ((Prohandle)p_spool->owner, p_spool->name, param_name); TEST_CALL_REPORT("procbl_delete_spool_param", "ProCblSpoolParameterDelete",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolFromLogicalGet Purpose : Return list of imported, but not created spools \*---------------------------------------------------------------------------*/ ProError ProCblSpoolFromLogicalGet ( ProAssembly assy, /* In: assemlbly */ ProName **p_w_name, /* Out: ProArray of spool names*/ int *num_spool) /* Out: number of spools */ { ProError status; int error, i; PRODEV_Name *p_spool_names; if (assy == NULL || num_spool == NULL || p_w_name == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_get_spools_from_logical ((Prohandle)assy, &p_spool_names); TEST_CALL_REPORT("procbl_get_spools_from_logical", "ProCblSpoolFromLogicalGet",(ProError)error, 0); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_NOT_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); *num_spool = error; status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_w_name); if (status != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); for (i = 0; i < *num_spool; i++) status = ProArrayObjectAdd ((ProArray*)p_w_name, PRO_VALUE_UNUSED, 1, p_spool_names[i]); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblSpoolFromLogicalCreate Purpose : creates spools from logical \*---------------------------------------------------------------------------*/ ProError ProCblSpoolFromLogicalCreate ( ProAssembly assy, /* In: assembly's hndle*/ ProName *p_w_name, /* In: spool_names */ int spool_num, /* In: spool num */ ProCblSpool **p_spools) /* Out: ProArray of spools user must free memory by ProArrayFree*/ { PRODEV_Name *p_spool_names; int error, i; ProError status; if (assy == NULL || p_w_name == NULL || p_spools == NULL) return (PRO_TK_BAD_INPUTS); status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1, (ProArray*)&p_spool_names); if (status != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); for (i = 0; i < spool_num; i++) status = ProArrayObjectAdd ((ProArray*)&p_spool_names, PRO_VALUE_UNUSED, 1, p_w_name[i]); error = procbl_create_spools_from_logical ((Prohandle)assy, spool_num, p_spool_names); TEST_CALL_REPORT("procbl_create_spools_from_logical", "ProCblSpoolFromLogicalCreate",(ProError)error, 0); status = ProArrayFree ((ProArray*)&p_spool_names); if (error == PRODEV_INVALID_INPUT) return (PRO_TK_E_FOUND); if (error == PRODEV_GENERAL_ERROR) return (PRO_TK_GENERAL_ERROR); status = ProArrayAlloc (spool_num, sizeof (ProCblSpool), 1, (ProArray*)p_spools); for (i = 0; i < spool_num; i++) { status = ProCblSpoolInit (assy, p_w_name[i], &(*p_spools)[i]); } return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Functions to route cables. \*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*\ Function : ProCblRoutingStart Purpose : Initializes routing procedure \*---------------------------------------------------------------------------*/ ProError ProCblRoutingStart ( ProCblCable *p_cables, /* In: ProArray of cables to route */ void **p_cable_route_data) /* Out: The cable routing data required for subsequent function calls to route cables through locations. The function allocates the space for this argument. */ { int error; PRODEV_Name *cable_names; int cable_num, i; if (p_cables == NULL || p_cable_route_data == NULL) return (PRO_TK_BAD_INPUTS); ProArraySizeGet ((ProArray)p_cables, &cable_num); ProArrayAlloc (cable_num, sizeof (PRODEV_Name), 1, (ProArray*)&cable_names); for (i = 0; i < cable_num; i++) ProCblCableNameGet (&p_cables[i], cable_names[i]); error = procbl_routing_start ((Prohandle)p_cables[0].p_owner->owner, (Prohandle)p_cables[0].p_owner->harness, cable_names, cable_num, p_cable_route_data); TEST_CALL_REPORT("procbl_routing_start", "ProCblRoutingStart",(ProError)error, 0); ProArrayFree ((ProArray*)&cable_names); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblRouteThruLocation Purpose : Finds or creates the location, and routes cables through it \*---------------------------------------------------------------------------*/ ProError ProCblRouteThruLocation ( void *p_cable_route_data, /* In: routing data */ ProCblLocRef *ref, /* In: referances */ int **r_location_ids, /* Out: The location identifiers. The function allocates the space for this argument, and reuse it*/ int *num_locs) /* Out: The number of locations. */ { int error; if (p_cable_route_data == NULL || ref == NULL || r_location_ids == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_route_thru_location (p_cable_route_data, ref, r_location_ids, num_locs); TEST_CALL_REPORT("procbl_route_thru_location", "ProCblRouteThruLocation",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); } /*---------------------------------------------------------------------------*\ Function : ProCblRoutingEnd Purpose : Ends the cable routing \*---------------------------------------------------------------------------*/ ProError ProCblRoutingEnd ( void **p_cable_route_data) /* In: The address of the cable routing data */ { int error; if (p_cable_route_data == NULL) return (PRO_TK_BAD_INPUTS); error = procbl_routing_end (p_cable_route_data); TEST_CALL_REPORT("procbl_routing_end", "ProCblRoutingEnd",(ProError)error, 0); if (error != PRODEV_NO_ERROR) return (PRO_TK_GENERAL_ERROR); return (PRO_TK_NO_ERROR); }