/*================================================================*\    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",