utilcable.c

Pro.TOOLKIT.Wildfire插件设计.配套光盘-141M.zip

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