You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1351 lines
53 KiB
1351 lines
53 KiB
/*==============================================================================
|
|
Copyright (c) 2003-2005 UGS Corporation
|
|
Unpublished - All Rights Reserved
|
|
==============================================================================*/
|
|
|
|
/**
|
|
@file
|
|
|
|
Interface definition for the CFM module
|
|
*/
|
|
|
|
/* */
|
|
|
|
#ifndef CFM_H
|
|
#define CFM_H
|
|
|
|
#include <unidefs.h>
|
|
|
|
#include <cfm/cfm_errors.h>
|
|
#include <cfm/cfm_tokens.h>
|
|
#include <common/tc_deprecation_macros.h>
|
|
#include <cfm/libcfm_exports.h>
|
|
|
|
/**
|
|
@defgroup CFM Configuration Management (CFM)
|
|
|
|
The Configuration Management (CFM) module provides the ability to configure Items and
|
|
the definition of the rules that drive that configuration.
|
|
|
|
The CFM module works with the following classes of object:
|
|
<ul>
|
|
<li>Revision Rule
|
|
<li>Revision Rule Entry
|
|
</ul>
|
|
|
|
<b>Common Return Values</b>
|
|
|
|
#CFM_invalid_tag - The rule and/or preset_rule tags are invalid. <br>
|
|
#CFM_value_not_found - No rule of that name could be found.
|
|
|
|
@{
|
|
*/
|
|
|
|
/**
|
|
@name Entry Types for Revision Rules
|
|
@{
|
|
*/
|
|
|
|
/** @if DOX_IGNORE
|
|
Obviously these should be an enum, but this is process_pif we're talking about...
|
|
If you extend this list then please extend CFMRuleEntry::entryTypeAsString too
|
|
@endif */
|
|
|
|
#define CFM_entry_working 0
|
|
#define CFM_entry_status 1
|
|
#define CFM_entry_override 2
|
|
#define CFM_entry_date 3
|
|
#define CFM_entry_unit_no 4
|
|
#define CFM_entry_group 5
|
|
#define CFM_entry_precise 6
|
|
#define CFM_entry_latest 7
|
|
#define CFM_entry_end_item 8
|
|
#define CFM_entry_group_item_type 9
|
|
#define CFM_entry_branch 10
|
|
#define CFM_entry_nested_eff 11
|
|
#define CFM_entry_group_occ_type 12
|
|
/** @} */
|
|
|
|
/**
|
|
@name Config Types for Status Entries
|
|
@{
|
|
*/
|
|
#define CFM_status_released_date 0
|
|
#define CFM_status_effective_date 1
|
|
#define CFM_status_unit_no 2
|
|
/** @} */
|
|
|
|
/**
|
|
@name Config Types for Latest Entries
|
|
@{
|
|
*/
|
|
#define CFM_latest_creation_date 0
|
|
#define CFM_latest_alphanumeric 1
|
|
#define CFM_latest_numeric 2
|
|
#define CFM_latest_alpha_plus_no 3
|
|
/** @} */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
/** @if DOX_IGNORE
|
|
don't fiddle with anything below this lot -- it is processed by a program that
|
|
builds the procedural interface code by parsing the definitions.
|
|
To be precise the program ignores everything down to a line that
|
|
starts (COMMENT) END OF HEADER (COMMENT) so you can safely add typedefs
|
|
and hash defines to the top of this file
|
|
@endif */
|
|
/* END OF HEADER */
|
|
|
|
/**
|
|
@name CFM Rule
|
|
|
|
<b>Common Return Values:</b>
|
|
|
|
<table>
|
|
<tr><td>#CFM_invalid_entry_type </td><td>The type given is not one of the valid entry types.</td></tr>
|
|
<tr><td>#CFM_entry_not_in_rule </td><td>The given entry is not contained in the given rule.</td></tr>
|
|
<tr><td>#CFM_cant_move_entry_in_group</td><td>An entry that is in a group cannot be moved.</td></tr>
|
|
<tr><td>#CFM_entry_already_in_group </td><td>One or more of the entries is already in a group.</td></tr>
|
|
<tr><td>#CFM_entry_is_not_groupable </td><td>Only working and status entries may be grouped.</td></tr>
|
|
</table>
|
|
@{
|
|
*/
|
|
|
|
/**
|
|
Creates a revision rule with given name and description.
|
|
Use the WSOM functions if you need to change the name and/or description in the future.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
The rule name should be unique, otherwise the rule can not be saved.
|
|
*/
|
|
extern CFM_API int CFM_rule_create(
|
|
const char* rule_name, /**< (I) Name for the new rule */
|
|
const char* description, /**< (I) Description for the new rule */
|
|
tag_t* new_rule /**< (O) Tag of the newly created rule */
|
|
);
|
|
|
|
/**
|
|
Copies the given revision rule and all its rule entries into a new revision rule with given name.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
The new rule name should be unique, otherwise the rule can not be saved.
|
|
*/
|
|
extern CFM_API int CFM_rule_copy(
|
|
tag_t rule_to_copy, /**< (I) Tag of the rule to copy */
|
|
const char* new_name, /**< (I) Name for the new copy */
|
|
tag_t* new_rule /**< (O) Tag of the newly created copy */
|
|
);
|
|
|
|
/**
|
|
Forces a re-evaluation of a rule contents.
|
|
This will pick up any changes in the contents of override folders.
|
|
|
|
@note This function is automatically invoked whenever #BOM_set_window_config_rule is called,
|
|
e.g. on setting revision rule in PSE.
|
|
*/
|
|
extern CFM_API int CFM_rule_reevaluate(
|
|
tag_t rule /**< (I) Tag of the rule to reevaluate */
|
|
);
|
|
|
|
/**
|
|
Creates a new entry of given type and adds it to the end of the list of entries in the rule.
|
|
|
|
Valid entry types are as follows:
|
|
|
|
<table>
|
|
<tr><td>Token</td> <td>Entry Type</td> <td>Default Settings</td></tr>
|
|
<tr><td>#CFM_entry_working</td> <td>Working entry</td> <td>No user or group specified</td></tr>
|
|
<tr><td>#CFM_entry_status</td> <td>Status entry</td> <td>ANY status and type</td></tr>
|
|
<tr><td>#CFM_entry_latest</td> <td>Latest entry</td> <td>Type #CFM_latest_creation_date</td></tr>
|
|
<tr><td>#CFM_entry_override</td><td>Override entry</td> <td>No override folder specified</td></tr>
|
|
<tr><td>#CFM_entry_date</td> <td>Date entry</td> <td>"Today"</td></tr>
|
|
<tr><td>#CFM_entry_unit_no</td> <td>Unit Number entry</td><td>Unit number 0</td></tr>
|
|
<tr><td>#CFM_entry_end_item</td><td>End Item entry</td> <td>No end item</td></tr>
|
|
<tr><td>#CFM_entry_precise</td> <td>Precise entry</td> <td>N/A</td></tr>
|
|
<tr><td>#CFM_entry_branch</td> <td>Branch entry</td> <td>No branch definition specified</td></tr>
|
|
</table>
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
A rule may only contain at most one of each of the last three entry types listed above.
|
|
An attempt to add a second will result in an error.
|
|
|
|
<b>Return Values:</b>
|
|
|
|
#CFM_duplicate_date_entry - Only one date entry is allowed per rule. <br>
|
|
#CFM_duplicate_unitno_entry - Only one unit number entry is allowed per rule.
|
|
*/
|
|
extern CFM_API int CFM_rule_add_entry(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
int type, /**< (I) Type of entry to add to rule */
|
|
tag_t* entry /**< (O) Tag of the newly created entry */
|
|
);
|
|
|
|
/**
|
|
Removes the given entry from the given rule, and deletes the entry.
|
|
*/
|
|
extern CFM_API int CFM_rule_delete_entry(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
tag_t entry /**< (I) Tag of the entry to delete from the rule */
|
|
);
|
|
|
|
/**
|
|
Removes the given old entry from the rule and puts the new entry
|
|
in its former position in the list of entries of rule.
|
|
The old entry is deleted.
|
|
*/
|
|
extern CFM_API int CFM_rule_replace_entry(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
tag_t old_entry, /**< (I) Tag of the entry to be replaced */
|
|
int type, /**< (I) Type of replacement entry */
|
|
tag_t* new_entry /**< (O) Tag of the replacement entry */
|
|
);
|
|
|
|
/**
|
|
Provides the ordered list of entries in the given rule.
|
|
*/
|
|
extern CFM_API int CFM_rule_list_entries(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
int* n_entries, /**< (O) Number of entries in the rule */
|
|
tag_t** entries, /**< (OF) n_entries Ordered list of entries */
|
|
int** entry_types /**< (OF) n_entries Ordered list of entry types */
|
|
);
|
|
|
|
/**
|
|
Moves the given entry up one place in the list of entries of rule.
|
|
This has no effect if the entry is already at the head of the list.
|
|
*/
|
|
extern CFM_API int CFM_rule_move_entry_up(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
tag_t entry /**< (I) Tag of the entry to move */
|
|
);
|
|
|
|
/**
|
|
Move an entry down within a rule - does nothing if at bottom already
|
|
Moves the given entry down one place in the list of entries of rule.
|
|
This has no effect if the
|
|
*/
|
|
extern CFM_API int CFM_rule_move_entry_down(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
tag_t entry /**< (I) Tag of the entry to move */
|
|
);
|
|
|
|
/**
|
|
Groups together all the given entries (which must be in the rule) into a group entry.
|
|
The group entry is placed into the rule at the former position of the first in the given list of entries.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
Only working and status entries may be grouped. All the entries in a group must be of the same
|
|
type, i.e. all working or all status. For status entries, all must use the same criteria to
|
|
decide 'latest' (release date, effective date, or effective unit number). For example, it is not
|
|
possible to decide between a release date and a unit number which one is latest.
|
|
|
|
<b>Return Values:</b>
|
|
|
|
#CFM_entry_is_not_groupable - Only working and status entries may be grouped.<br>
|
|
#CFM_entry_incompatible_w_group - All entries in the group must be the same type and use the same criterion for latest.
|
|
*/
|
|
extern CFM_API int CFM_rule_group_entries(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
int n_entries, /**< (I) Number of entries to group */
|
|
tag_t* entries, /**< (I) n_entries Tags of entries to group */
|
|
tag_t* group_entry /**< (O) Tag of newly created group entry */
|
|
);
|
|
|
|
/**
|
|
Groups together all the given entries (which must be in the rule) into a group item type entry.
|
|
The group entry is placed into the rule at the former position of the first in the given list of entries.
|
|
*/
|
|
extern CFM_API int CFM_rule_group_entries_by_itemtype(
|
|
tag_t rule, /**< (I) Tag of the rule */
|
|
int n_entries, /**< (I) Number of entries to group */
|
|
tag_t* entries, /**< (I) n_entries Tags of entries to group */
|
|
int n_itemtypes, /**< (I) Number of entries itemm types */
|
|
char** item_types, /**< (I) item_types char array */
|
|
tag_t* group_entry /**< (O) Tag of newly created group entry */
|
|
);
|
|
|
|
/**
|
|
Groups together all the given entries (which must be in the revision rule) into a group occurrence type entry.
|
|
Group entry is placed into the revision rule at the former position of the first in the given list of entries.
|
|
|
|
@note If the entries contains something invalid or NULLTAG, further operation will be stopped.
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success
|
|
<li>#PS_invalid_value if any value @p n_entries and n_occurrence_types is equal to zero
|
|
<li>#CFM_invalid_revision_rule if value @p rule is not valid RevisionRule
|
|
<li>#CFM_invalid_occurrence_type if any value in @p occurrence_types is invalid occurrence type.
|
|
<li>#CFM_invalid_entry_type if any value in @p entries is invalid entry type.
|
|
<li>Possibly some other cfm errors
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_rule_group_entries_by_occurrence_type(
|
|
const tag_t rule, /**< (I) The Revision Rule. */
|
|
int n_entries, /**< (I) Number of entries to group. */
|
|
const tag_t* entries, /**< (I) n_entries Entries to group. */
|
|
int n_occurrence_types, /**< (I) Number of Occurrence Types. */
|
|
const char** occurrence_types, /**< (I) n_occurrence_types The Occurrence types. */
|
|
tag_t* group_entry /**< (O) The newly created group entry. */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
@name CFM Entry
|
|
@{
|
|
*/
|
|
|
|
/**
|
|
Finds the type of the given entry.
|
|
|
|
Possible entry types are as follows:
|
|
|
|
<table>
|
|
<tr><td>#CFM_entry_working </td><td>Working entry </td></tr>
|
|
<tr><td>#CFM_entry_status </td><td>Status entry </td></tr>
|
|
<tr><td>#CFM_entry_override</td><td>Override entry </td></tr>
|
|
<tr><td>#CFM_entry_date </td><td>Date entry </td></tr>
|
|
<tr><td>#CFM_entry_unit_no </td><td>Unit number entry</td></tr>
|
|
<tr><td>#CFM_entry_precise </td><td>Precise entry </td></tr>
|
|
</table>
|
|
*/
|
|
extern CFM_API int CFM_entry_ask_type(
|
|
tag_t entry, /**< (I) Tag of the entry */
|
|
int* type /**< (O) Type of the entry */
|
|
);
|
|
|
|
/**
|
|
Finds the user associated with the given working entry.
|
|
There may be no user, in which case the current_user flag is false and the user tag is #NULLTAG.
|
|
|
|
If the current_user flag is true, then the user tag should be ignored (it will be #NULLTAG anyway).
|
|
*/
|
|
extern CFM_API int CFM_working_entry_ask_user(
|
|
tag_t entry, /**< (I) Tag of the working entry */
|
|
logical* current_user, /**< (O) Set true if the user evaluates to the logged in user */
|
|
tag_t* user /**< (O) Tag of the user */
|
|
);
|
|
|
|
/**
|
|
Sets the user associated with the given working entry.
|
|
If you want not to have a user associated with the entry,
|
|
then set the current_user flag to false, and the user tag to #NULLTAG.
|
|
|
|
If the current_user flag is set to true, then the user tag will be ignored.
|
|
*/
|
|
extern CFM_API int CFM_working_entry_set_user(
|
|
tag_t entry, /**< (I) Tag of the working entry */
|
|
logical current_user, /**< (I) Set true to evaluate to the logged in user */
|
|
tag_t user /**< (I) Tag of the user */
|
|
);
|
|
|
|
/**
|
|
Finds the group associated with the given working entry.
|
|
There may be no group, in which case the current_group flag is false and the group tag is #NULLTAG.
|
|
|
|
If the current_group flag is true, then the group tag should be ignored (it will be #NULLTAG anyway).
|
|
*/
|
|
extern CFM_API int CFM_working_entry_ask_group(
|
|
tag_t entry, /**< (I) Tag of the working entry */
|
|
logical* current_group, /**< (O) Set true if the group evaluates to the logged in group */
|
|
tag_t* user /**< (O) Tag of the user */
|
|
);
|
|
|
|
/**
|
|
Sets the group associated with the given working entry.
|
|
If you want not to have a group associated with the entry,
|
|
then set the current_group flag to false, and the group tag to #NULLTAG.
|
|
|
|
If the current_group flag is set to true, then the group tag will be ignored.
|
|
*/
|
|
extern CFM_API int CFM_working_entry_set_group(
|
|
tag_t entry, /**< (I) Tag of the working entry */
|
|
logical current_group, /**< (I) Set true to evaluate to the logged in group */
|
|
tag_t user /**< (I) Tag of the group */
|
|
);
|
|
|
|
/**
|
|
Finds the tag of the status type for the given status entry.
|
|
If the returned tag is #NULLTAG, this indicates "Any Release Status."
|
|
*/
|
|
extern CFM_API int CFM_status_entry_ask_status(
|
|
tag_t entry, /**< (I) Tag of the status entry */
|
|
tag_t* status_type /**< (O) Tag of the status type */
|
|
);
|
|
|
|
/**
|
|
Sets the status type for the given status entry.
|
|
*/
|
|
extern CFM_API int CFM_status_entry_set_status(
|
|
tag_t entry, /**< (I) Tag of the status entry */
|
|
tag_t status_type /**< (I) Tag of the status type. Set to #NULLTAG to specify ANY status type. */
|
|
);
|
|
|
|
/**
|
|
Finds the type of the given status entry. Possible types of status entry are:
|
|
|
|
<table>
|
|
<tr><td>#CFM_status_released_date</td> <td>Configure using the date the status was added</td></tr>
|
|
<tr><td>#CFM_status_effective_date</td> <td>Configure using the date effectivity on the status</td></tr>
|
|
<tr><td>#CFM_status_unit_no</td> <td>Configure using the unit no effectivity on the status</td></tr>
|
|
</table>
|
|
*/
|
|
extern CFM_API int CFM_status_entry_ask_type(
|
|
tag_t entry, /**< (I) Tag of the status entry */
|
|
int* type /**< (O) Type of status entry */
|
|
);
|
|
|
|
/**
|
|
Sets the type of the given status entry. Possible types of status entry are:
|
|
|
|
<table>
|
|
<tr><td>#CFM_status_released_date</td> <td>Configure using the date the status was added</td></tr>
|
|
<tr><td>#CFM_status_effective_date</td><td>Configure using the date effectivity on the status</td></tr>
|
|
<tr><td>#CFM_status_unit_no</td> <td>Configure using the unit no effectivity on the status</td></tr>
|
|
</table>
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
Only #CFM_status_released_date may be used in conjunction with "Any Release Status."
|
|
|
|
<b>Return Values:</b>
|
|
|
|
#CFM_invalid_status_entry_type - The type given is not one of the valid configuration types. <br>
|
|
#CFM_invalid_status_date_combo - Only Released Date configuration may be used with Status = Any.
|
|
*/
|
|
extern CFM_API int CFM_status_entry_set_type(
|
|
tag_t entry, /**< (I) Tag of the status entry */
|
|
int type /**< (I) Type of status entry */
|
|
);
|
|
|
|
/**
|
|
Finds the tag of the override folder for the given override entry.
|
|
If the returned tag is #NULLTAG, this indicates a "place-holding" override folder,
|
|
which can be used in Teamcenter Engineering UIF to allow
|
|
non-privileged users to set an override folder for a Revision Rule.
|
|
*/
|
|
extern CFM_API int CFM_override_entry_ask_folder(
|
|
tag_t entry, /**< (I) Tag of the override entry */
|
|
tag_t* folder /**< (O) Tag of the override folder */
|
|
);
|
|
|
|
/**
|
|
Sets the override folder for the given override entry.
|
|
|
|
Set the override folder to be #NULLTAG to indicate a "place-holding" override folder,
|
|
which can be used in Teamcenter Engineering UIF to allow non-privileged users to
|
|
set an override folder for a Revision Rule.
|
|
(Whilst empty, this override entry will have no effect on configuration.)
|
|
*/
|
|
extern CFM_API int CFM_override_entry_set_folder(
|
|
tag_t entry, /**< (I) Tag of the override entry */
|
|
tag_t folder /**< (I) Tag of the override folder */
|
|
);
|
|
|
|
/**
|
|
Finds the tag of the branch for the given branch entry.
|
|
|
|
If the returned tag is #NULLTAG, this indicates a "place-holding" branch,
|
|
which can be used in Teamcenter Engineering UIF to allow
|
|
non-privileged users to set a branch for a Revision Rule.
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success.
|
|
<li>#CXPOM_wrong_class if the input tag is invalid
|
|
</ul>
|
|
|
|
*/
|
|
extern CFM_API int CFM_branch_entry_ask_branch(
|
|
tag_t entry, /**< (I) Tag of the branch entry */
|
|
tag_t* branch /**< (O) Tag of the branch */
|
|
);
|
|
|
|
/**
|
|
Sets the branch for the given branch entry.
|
|
|
|
Set the branch to be #NULLTAG to indicate a "place-holding" branch,
|
|
which can be used in Teamcenter Engineering UIF to allow non-privileged users to
|
|
set a branch for a Revision Rule.
|
|
|
|
(Whilst empty, this branch entry will have no effect on configuration.)
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success.
|
|
<li>#CXPOM_wrong_class if any of the input tag is invalid
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_branch_entry_set_branch(
|
|
tag_t entry, /**< (I) Tag of the branch entry */
|
|
tag_t branch /**< (I) Tag of the branch */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
Gives the date entry of the specified Revision Rule.
|
|
*/
|
|
extern CFM_API int CFM_rule_ask_date(
|
|
tag_t rule, /**< (I) Revision Rule */
|
|
date_t* date /**< (O) Date entry of the Revision Rule */
|
|
);
|
|
/**
|
|
Sets the date entry into the Revision Rule. If a date entry already exists
|
|
with the revision rule it will be updated.
|
|
*/
|
|
extern CFM_API int CFM_rule_set_date(
|
|
tag_t rule, /**< (I) Revision Rule to be modified */
|
|
date_t date /**< (I) Date entry to be set on the Revision Rule */
|
|
);
|
|
|
|
/**
|
|
Asks the configuration type of a latest entry, which specifies how 'latest' is decided.
|
|
*/
|
|
extern CFM_API int CFM_latest_entry_ask_type(
|
|
tag_t entry, /**< (I) Tag of the 'latest' entry */
|
|
int* type /**< (O) Defines the way in which 'latest' is decided:
|
|
#CFM_latest_creation_date, #CFM_latest_alphanumeric,
|
|
#CFM_latest_alpha_plus_no or #CFM_latest_numeric */
|
|
);
|
|
|
|
/**
|
|
Sets the configuration type of a latest entry, which specifies how 'latest' is decided.
|
|
*/
|
|
extern CFM_API int CFM_latest_entry_set_type(
|
|
tag_t entry, /**< (I) Tag of the 'latest' entry */
|
|
int type /**< (I) Defines the way in which 'latest' is decided:
|
|
#CFM_latest_creation_date, #CFM_latest_alphanumeric,
|
|
#CFM_latest_alpha_plus_no or #CFM_latest_numeric */
|
|
);
|
|
|
|
/**
|
|
Provides the list of entries in the given group entry.
|
|
*/
|
|
extern CFM_API int CFM_group_entry_list_entries(
|
|
tag_t group_entry, /**< (I) Tag of the group entry */
|
|
int* n_entries, /**< (O) Number of entries in the group */
|
|
tag_t** entries /**< (OF) n_entries Ordered list of entries */
|
|
);
|
|
|
|
/**
|
|
Provides the list of item types in the given group item type entry.
|
|
*/
|
|
extern CFM_API int CFM_group_itemtype_entry_ask_itemtypes(
|
|
tag_t entry, /**< (I) Tag of the group IT entry */
|
|
int* n_itemtypes, /**< (O) Number of item types */
|
|
char*** itemtypes /**< (OF) n_itemtypes List of item types */
|
|
);
|
|
|
|
/**
|
|
Sets the item types of a groupp item type entry.
|
|
*/
|
|
extern CFM_API int CFM_group_itemtype_entry_set_itemtypes(
|
|
tag_t entry, /**< (I) Tag of the group IT entry */
|
|
int n_itemtypes, /**< (I) Number of item types */
|
|
char** itemtypes /**< (I) n_itemtypes List of item types */
|
|
);
|
|
|
|
/**
|
|
Provides the list of occurrence types in a group occurrence type entry.
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success
|
|
<li>#PS_invalid_value if input @p group_occurrence_type is NULLTAG
|
|
<li>CFM_invalid_group_occurrence_entry if value @p group_occurrence_type is not valid group occurrence type
|
|
<li>Possibly some other cfm errors
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_find_occurrence_types_in_group(
|
|
const tag_t group_occurrence_type, /**< (I) The Group Occurrence Type. */
|
|
int* n_occurrence_types, /**< (O) Number of Occurrence Types. */
|
|
char*** occurrence_types /**< (OF) n_occurrence_types The Occurrence Types. */
|
|
);
|
|
/**
|
|
Sets the occurrence types on a group occurrence type entry.
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success
|
|
<li>#PS_invalid_value if input @p group_occurrence_type is NULLTAG
|
|
<li>CFM_invalid_group_occurrence_entry if value @p group_occurrence_type is not valid group occurrence type
|
|
<li>#CFM_invalid_occurrence_type if any value in @p occurrence_types is invalid occurrence type.
|
|
<li>Possibly some other cfm errors
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_set_occurrence_types_in_group(
|
|
const tag_t group_occurrence_type, /**< (I) The Group Occurrence Type. */
|
|
int n_occurrence_types, /**< (I) Number of Occurrence Types. */
|
|
const char** occurrence_types /**< (I) n_occurrence_types The Occurrence Types. */
|
|
);
|
|
|
|
/**
|
|
Adds the given entry to the given group entry.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
Only working and status entries may be added into a group. All the entries in a group must be of
|
|
the same type, i.e. all working or all status. For status entries, all must use the same
|
|
criteria to decide 'latest' (release date, effective date, or effective unit number). For
|
|
example, it is not possible to decide between a release date and a unit number which one is latest.
|
|
|
|
<b>Return Values:</b>
|
|
|
|
#CFM_entry_is_not_groupable - Only working and status entries may be grouped.<br>
|
|
#CFM_entry_incompatible_w_group - New entry has different type or latest criterion from those already in the group.
|
|
*/
|
|
extern CFM_API int CFM_group_entry_add_entry(
|
|
tag_t group_entry, /**< (I) Tag of the group entry */
|
|
tag_t entry_to_add /**< (I) Tag of the entry to add to the group */
|
|
);
|
|
|
|
/**
|
|
Removes entry from group, entry is added back into rule.
|
|
If group is left empty, it is deleted.
|
|
|
|
<b>Return Values:</b>
|
|
|
|
#CFM_entry_not_in_group - The entry is not in the given group.
|
|
*/
|
|
extern CFM_API int CFM_group_entry_remove_entry(
|
|
tag_t group_entry, /**< (I) Tag of the group entry */
|
|
tag_t entry_in_group /**< (I) Tag of the entry to remove from the group */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_ask_unit(
|
|
tag_t rule, /**< (I) */
|
|
int* unit /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_set_unit(
|
|
tag_t rule, /**< (I) */
|
|
int unit /**< (I) */
|
|
);
|
|
|
|
/**
|
|
Returns the revision rule modifier currently in effect. This modifier
|
|
can define an End Item, End Item Revision, Date or Unit Number that
|
|
will override those set in the revision rule itself.
|
|
*/
|
|
extern CFM_API int CFM_rule_ask_modifier(
|
|
tag_t rule, /**< (I) */
|
|
tag_t * modifier /**< (O) */
|
|
);
|
|
|
|
/**
|
|
Sets the current modifier of the revision rule. This modifier can define
|
|
an End Item, End Item Revision, Date or Unit Number that will
|
|
override those set in the revision rule itself.
|
|
*/
|
|
extern CFM_API int CFM_rule_set_modifier(
|
|
tag_t rule, /**< (I) */
|
|
tag_t modifier /**< (I) */
|
|
);
|
|
|
|
/**
|
|
Applies the revision rule to the effectivity mappings of the item revision
|
|
in order to generate a revision rule modifier that can be applied to
|
|
the rule using CFM_rule_set_modifier. If no mapping applies then
|
|
new_modifier will be returned as NULLTAG.
|
|
|
|
The override_parent flag indicates whether the mapping is allowed to
|
|
override non-null settings in the parent configuration. This is usually
|
|
set to true. It is only set to false for product structure roots when
|
|
we want the values stored in the revision rule itself to take precedence
|
|
over the root mapping.
|
|
|
|
If old_modifier is input as NULLTAG then this function will create a new
|
|
modifier for new_modifier. If old_modifier is input as non-NULLTAG then
|
|
this function will update the existing modifier.
|
|
|
|
Note that if old_modifier is not NULLTAG, but new_modifier is returned as
|
|
NULLTAG, then it is up to the caller to delete the old_modifier object.
|
|
*/
|
|
extern CFM_API int CFM_rule_generate_modifier(
|
|
tag_t rule, /**< (I) */
|
|
tag_t itemrev, /**< (I) */
|
|
logical override_parent, /**< (I) */
|
|
tag_t old_modifier, /**< (I) */
|
|
tag_t * new_modifier /**< (O) */
|
|
);
|
|
|
|
/**
|
|
Applies nested effectivity to the given set of items. It assumes that
|
|
these items represent a path down a product structure. It will return
|
|
the configured revision of each item and the modifier that was generated
|
|
against that itemrev. This modifier can then be used to further configure
|
|
sub-structure.
|
|
|
|
The override_parent flag indicates whether the first mapping is allowed to
|
|
override non-null settings in the parent configuration. This flag only
|
|
affects the first item in the array. This will be set to true if the first
|
|
item is not the root of the product structure. It is only set to false for
|
|
product structure root items when we want the values stored in the revision
|
|
rule itself to take precedence over the root mapping.
|
|
*/
|
|
extern CFM_API int CFM_rule_generate_modifier_chain(
|
|
tag_t rule, /**< (I) */
|
|
int n_items, /**< (I) */
|
|
tag_t * items, /**< (I) n_items */
|
|
logical override_parent, /**< (I) */
|
|
tag_t ** itemrevs, /**< (OF) n_items */
|
|
tag_t ** modifiers /**< (OF) n_items */
|
|
);
|
|
|
|
/**
|
|
Applies nested effectivity to the given set of configuration items, and
|
|
returns the configured revision of hte last item and the last modifier
|
|
(which does not necessarily belong to the last item). It assumes that
|
|
these items represent a partial path down a product structure. Any
|
|
non-configuration items in the list have no effect on the result. The
|
|
last modifier can then be used to further configure sub-structure.
|
|
|
|
The override_parent flag indicates whether the first mapping is allowed to
|
|
override non-null settings in the parent configuration. This flag only
|
|
affects the first item in the array. This will be set to true if the first
|
|
item is not the root of the product structure. It is only set to false for
|
|
product structure root items when we want the values stored in the revision
|
|
rule itself to take precedence over the root mapping.
|
|
*/
|
|
extern CFM_API int CFM_rule_generate_end_modifier(
|
|
tag_t rule, /**< (I) */
|
|
int n_items, /**< (I) */
|
|
tag_t * items, /**< (I) n_items */
|
|
logical override_parent, /**< (I) */
|
|
tag_t * last_itemrev, /**< (O) */
|
|
tag_t * last_modifier /**< (O) */
|
|
);
|
|
|
|
/**
|
|
Deletes a revision rule modifier. For performance reasons, it is recommended
|
|
that you use CFM_rule_set_modifier to ensure that your revision rule isn't
|
|
referencing this modifier. It shouldn't do any harm if you don't do this,
|
|
but it may slow down subsequent configuration calls.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
Only use this function on modifiers created by a call to CFM_rule_generate_modifier.
|
|
Do not use it on modifiers generated on a BOMLine. Doing so will interfere with
|
|
BOM level configuration management.
|
|
*/
|
|
extern CFM_API int CFM_rule_delete_modifier(
|
|
tag_t modifier /**< (I) */
|
|
);
|
|
|
|
/**
|
|
Gives the end item set on the given rule.
|
|
*/
|
|
extern CFM_API int CFM_rule_ask_end_item(
|
|
tag_t rule, /**< (I) The rule being queried */
|
|
tag_t* end_item /**< (O) The end item used by any of the rule status entries
|
|
that are configured by effective date or unit */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_ask_end_item_rev(
|
|
tag_t rule, /**< (I) The rule being queried */
|
|
tag_t* end_item_rev /**< (O) The end item revision used by any of the rule status entries
|
|
that are configured by effective date or unit */
|
|
);
|
|
|
|
/**
|
|
Sets the end item on the given rule.
|
|
*/
|
|
extern CFM_API int CFM_rule_set_end_item(
|
|
tag_t rule, /**< (I) The rule being modified */
|
|
tag_t end_item /**< (I) The end item used by any of the rule status entries that
|
|
are configured by effective date or unit */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_set_end_item_rev(
|
|
tag_t rule, /**< (I) The rule being modified */
|
|
tag_t end_item_rev /**< (I) The end item revision used by any of the rule status entries that
|
|
are configured by effective date or unit */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_add_intent(
|
|
tag_t rule, /**< (I) */
|
|
tag_t intent /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_remove_intent(
|
|
tag_t rule, /**< (I) */
|
|
tag_t intent /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_rule_list_intents(
|
|
tag_t rule, /**< (I) */
|
|
int* n_intents, /**< (O) */
|
|
tag_t** intents /**< (OF) n_intents */
|
|
);
|
|
|
|
/**
|
|
@name CFM Item
|
|
@{
|
|
*/
|
|
|
|
/**
|
|
Finds the revision of the given item that is configured when
|
|
the given revision rule is used to configure the given item.
|
|
Also returns a textual representation of which entry/entries
|
|
in the rule caused the particular revision to be configured.
|
|
|
|
If no revision of the item is configured by the rule,
|
|
#NULLTAG is returned as the configured revision.
|
|
|
|
By default, this call is not aware of nested effectivity.
|
|
If you want to make it aware of nested effectivity, set
|
|
the preference CFMNestedEffectivityOverride to -1.
|
|
|
|
Callers that are aware of nested effectivity should use
|
|
CFM_item_ask_configured_base instead of this. Callers
|
|
that cannot handle nested effectivity, but would like
|
|
to try, can call CFM_item_ask_configured_nested.
|
|
*/
|
|
extern CFM_API int CFM_item_ask_configured(
|
|
tag_t rule, /**< (I) Tag of the revision rule to use for the configuration */
|
|
tag_t item, /**< (I) Tag of the item to configure */
|
|
tag_t* configured_rev, /**< (O) Tag of the configured revision (or #NULLTAG) */
|
|
char** how_configured /**< (OF) An explanation of why the particular revision was configured */
|
|
);
|
|
|
|
/**
|
|
Retrieves the revisions of the Items configured by @p rev_rule.
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success.
|
|
<li>#CFM_invalid_tag if @p rev_rule is invalid or #NULLTAG or @p items_and_revs contains an invalid tag.
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_items_ask_configured(
|
|
tag_t rev_rule, /**< (I) The Revision rule to use for the configuration. */
|
|
int n_items_and_revs, /**< (I) Number of Item and Item Revision objects. */
|
|
const tag_t* items_and_revs, /**< (I) n_items_and_revs The objects to be configured.
|
|
<br/>This can contain a mixture of Item and Item Revision objects.
|
|
<br/>For precise revision rule, if an Item Revision is a match, the same revision will be the configured revision.
|
|
<br/>For all other rules, the rule matches upon the Item of the given revision. */
|
|
tag_t** configured_revs, /**< (OF) n_items_and_revs The configured revisions.
|
|
<br/>If no revision of the item is configured by the rule, the associated value will be #NULLTAG.
|
|
<br/>If the object provided in @p items_and_revs is #NULLTAG or of type other than Item or Item Revision,
|
|
the associated value will be #NULLTAG. */
|
|
char*** how_configured /**< (OF) n_items_and_revs Provides the reason to explain how a specific revision is configured.
|
|
<br/>If the revision is not configured, the associated value will be an empty string.
|
|
<br/>The array is packed, which means that the memory is to be deallocated by calling #MEM_free on the container only. */
|
|
);
|
|
|
|
/**
|
|
Finds the revision of the given item that is configured when
|
|
the given revision rule is used to configure the given item.
|
|
Also returns a textual representation of which entry/entries
|
|
in the rule caused the particular revision to be configured.
|
|
|
|
If no revision of the item is configured by the rule,
|
|
#NULLTAG is returned as the configured revision.
|
|
|
|
This call should be used by clients that are aware of
|
|
nested effectivity, and are generating revision rule
|
|
modifiers.
|
|
*/
|
|
extern CFM_API int CFM_item_ask_configured_base(
|
|
tag_t rule, /**< (I) Tag of the revision rule to use for the configuration */
|
|
tag_t item, /**< (I) Tag of the item to configure */
|
|
tag_t* configured_rev, /**< (O) Tag of the configured revision (or #NULLTAG) */
|
|
char** how_configured /**< (OF) An explanation of why the particular revision was configured */
|
|
);
|
|
|
|
/**
|
|
Finds the revision of the given item that is configured when
|
|
the given revision rule is used to configure the given item.
|
|
Also returns a textual representation of which entry/entries
|
|
in the rule caused the particular revision to be configured.
|
|
|
|
If no revision of the item is configured by the rule,
|
|
#NULLTAG is returned as the configured revision.
|
|
|
|
This call is different from CFM_item_ask_configured in that
|
|
it attempts to resolve nested effectivity configuration
|
|
internally.Note that in the absence of product structure this
|
|
is only an approximation of the configuration. It cannot handle
|
|
multiple revisions per product structure.
|
|
|
|
This call should be used by clients that cannot handle nested
|
|
effectivity.
|
|
*/
|
|
extern CFM_API int CFM_item_ask_configured_nested(
|
|
tag_t rule, /**< (I) Tag of the revision rule to use for the configuration */
|
|
tag_t item, /**< (I) Tag of the item to configure */
|
|
tag_t* configured_rev, /**< (O) Tag of the configured revision (or #NULLTAG) */
|
|
char** how_configured /**< (OF) An explanation of why the particular revision was configured */
|
|
);
|
|
|
|
/**
|
|
Where a revision is configured (configured_rev != #NULLTAG),
|
|
returns a CFMHowConfigured record which describes how the rev was configured.
|
|
See description of #CFM_latest_of_latest.
|
|
|
|
@note After use you should free up the memory associated with
|
|
a CFMHowConfigured record by calling #CFM_free_how_configured.
|
|
*/
|
|
extern CFM_API int CFM_item_ask_how_configured(
|
|
tag_t rule, /**< (I) Tag of the revision rule to use for the configuration */
|
|
tag_t item, /**< (I) Tag of the item to configure */
|
|
tag_t* configured_rev, /**< (O) Tag of the configured revision (or #NULLTAG) */
|
|
tag_t* how_configured /**< (O) Describes how the revision rule decided on the configured revision */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
Turns a CFMHowConfigured record into the equivalent text as displayed in 'how configured' column.
|
|
*/
|
|
extern CFM_API int CFM_how_configured_text(
|
|
tag_t how_configured, /**< (I) Describes how the revision rule decided on a configured revision */
|
|
char** text /**< (OF) Text describing how the revision rule decided on a configured revision */
|
|
);
|
|
|
|
/**
|
|
For use in conjunction with Incremental Change (IC) configuration.
|
|
With IC you may find you have 'competing' states of data
|
|
(e.g. several occ datas setting transform for the same occurrence).
|
|
Where you have multiple such states configured, you will want to know which is 'latest'.
|
|
For each configured IC revision #CFM_item_ask_how_configured will have given you back a
|
|
CFMHowConfigured record describing how that revision was configured.
|
|
You then assemble the tags of those CFMHowConfigureds into an array,
|
|
and pass them to this function,
|
|
which will pass back the tag of the 'latest' one according to this rev rule.
|
|
*/
|
|
extern CFM_API int CFM_latest_of_latest(
|
|
tag_t rule, /**< (I) Tag of the revision rule to use for the configuration */
|
|
int n_candidates, /**< (I) Number of candidate how configured records */
|
|
tag_t* candidates, /**< (I) n_candidates Array of candidate how configured records */
|
|
tag_t* latest /**< (O) Points to the candidate how configured record deemed 'latest' */
|
|
);
|
|
|
|
/**
|
|
'User ref' allows the caller to associate some tag value to a CFMHowConfigured record,
|
|
and retrieve it again. With the example described for #CFM_latest_of_latest above,
|
|
the caller might store the tag of the corresponding configured occ data
|
|
against each candidate CFMHowConfigured record,
|
|
and retrieve the value from the 'winner' identified by #CFM_latest_of_latest.
|
|
*/
|
|
extern CFM_API int CFM_ask_how_configured_user_ref(
|
|
tag_t how_configured, /**< (I) Tag of the CFMHowConfigured record */
|
|
tag_t* user_ref /**< (O) Gives tag value previously stored using #CFM_set_how_configured_user_ref */
|
|
);
|
|
|
|
/**
|
|
'User ref' allows the caller to associate some tag value to a CFMHowConfigured record,
|
|
and retrieve it again. With the example described for #CFM_latest_of_latest above,
|
|
the caller might store the tag of the corresponding configured occ data
|
|
against each candidate CFMHowConfigured record,
|
|
and retrieve the value from the 'winner' identified by #CFM_latest_of_latest.
|
|
*/
|
|
extern CFM_API int CFM_set_how_configured_user_ref(
|
|
tag_t how_configured, /**< (I) Tag of the CFMHowConfigured record */
|
|
tag_t user_ref /**< (I) Tag value to be associated to the CFMHowConfigured record */
|
|
);
|
|
|
|
/**
|
|
Frees up the memory allocated to a CFMHowConfigured record.
|
|
*/
|
|
extern CFM_API int CFM_free_how_configured(
|
|
tag_t how_configured /**< (I) Tag of the CFMHowConfigured record no longer required */
|
|
);
|
|
|
|
/**
|
|
Finds the revision rule, either stored in the database or modified in the current session.
|
|
*/
|
|
extern CFM_API int CFM_find(
|
|
const char* name, /**< (I) Identifier for the rule name */
|
|
tag_t* rule /**< (O) Rule found */
|
|
);
|
|
|
|
/**
|
|
Lists the tags of all accessible preset rules stored in the database.
|
|
*/
|
|
extern CFM_API int CFM_list(
|
|
int* count, /**< (O) Number of rule tags found */
|
|
tag_t** rules /**< (OF) count Tags of the rules found in the database */
|
|
);
|
|
|
|
/**
|
|
Retrieves the list of all user-visible and non-suppressed Revision Rules in the database.
|
|
|
|
@returns
|
|
<ul>
|
|
<li>#ITK_ok on success.
|
|
<li>#POM_internal_error if the system has failed to load Revision Rules.
|
|
</ul>
|
|
*/
|
|
extern CFM_API int CFM_get_revision_rules(
|
|
int* count, /**< (O) Number of rule tags found */
|
|
tag_t** rules /**< (OF) count User-visible and non-suppressed Revision Rules found */
|
|
);
|
|
|
|
/**
|
|
This will force the rule to update the BOM window using the rule (if any).
|
|
This should be used if the settings associated with the rule have been changed.
|
|
*/
|
|
extern CFM_API int CFM_updated(
|
|
tag_t rule /**< (I) Tag of the rule to be updated */
|
|
);
|
|
|
|
/**
|
|
@name CFM Occurrence Effectivity
|
|
@{
|
|
*/
|
|
|
|
/**
|
|
Indicates if the occurrence is configured in the context of the given revision rule.
|
|
*/
|
|
extern CFM_API int CFM_is_occ_configured(
|
|
tag_t rule, /**< (I) Tag of the revision rule (contains configuration date) */
|
|
tag_t bvr, /**< (I) Tag of the parent BOMView Revision */
|
|
tag_t occ, /**< (I) Tag of the occurrence */
|
|
logical* answer /**< (O) True if the occurrence is configured, false otherwise. */
|
|
);
|
|
|
|
/**
|
|
Sets the date effectivity on the occurrence.
|
|
|
|
If necessary, this function will load the parent BOMView Revision and lock it for modify.
|
|
Note that this function modifies the occurrence in the loaded representation of the BOMView Revision only.
|
|
The modification will only be propagated to the database when the parent BOMView Revision is saved
|
|
using #AOM_save_with_extensions/#AOM_save_without_extensions. After saving the BOMView Revision, it should be unlocked.
|
|
*/
|
|
extern CFM_API int CFM_occ_set_effectivity(
|
|
tag_t bvr, /**< (I) Tag of the parent BOMView Revision */
|
|
tag_t occ, /**< (I) Tag of the occurrence */
|
|
tag_t eff_object /**< (I) Tag of the effectivity object containing the required date effectivity */
|
|
);
|
|
|
|
/**
|
|
Gives the date effectivity on the occurrence.
|
|
*/
|
|
extern CFM_API int CFM_occ_ask_effectivity(
|
|
tag_t bvr, /**< (I) Tag of the parent BOMView Revision */
|
|
tag_t occurrence, /**< (I) Tag of the occurrence */
|
|
tag_t* eff_object /**< (O) Tag of the effectivity object attached to the occurrence.
|
|
#NULLTAG if no effectivity. */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_create deprecated in Teamcenter 12.3. Use #PS_occ_eff_create instead.
|
|
<br/>In order to migrate CFM_date_info to Effectivity, please refer to the link -
|
|
http://docsstage.plm.automation.siemens.com/tdoc/tc/11.6/help#uid:occeff_understanding
|
|
@code
|
|
PS_occ_eff_create
|
|
PS_occ_eff_set_id
|
|
@endcode
|
|
|
|
Creates a new date effectivity object.
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_create","PS_occ_eff_create")
|
|
extern CFM_API int CFM_effectivity_create(
|
|
const char* id, /**< (I) Unique identifier for the new effectivity object */
|
|
tag_t* eff_object /**< (O) Tag of the newly created effectivity object */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_find deprecated in Teamcenter 12.3. Use #CFM_find_effectivities instead.
|
|
@code
|
|
CFM_find_effectivities
|
|
@endcode
|
|
|
|
Finds a specified effectivity object.
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_find","CFM_find_effectivities")
|
|
extern CFM_API int CFM_effectivity_find(
|
|
const char* id, /**< (I) Identifier of the sought effectivity object */
|
|
tag_t* eff_object /**< (O) Tag of the matching effectivity object */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_ask_id deprecated in Teamcenter 12.3. Use #PS_occ_eff_ask_id instead.
|
|
@code
|
|
PS_occ_eff_ask_id
|
|
@endcode
|
|
|
|
Gives the ID of the effectivity object.
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_ask_id","PS_occ_eff_ask_id")
|
|
extern CFM_API int CFM_effectivity_ask_id(
|
|
tag_t eff_object, /**< (I) Tag of the effectivity object */
|
|
char** id /**< (OF) ID of the effectivity object */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_set_id deprecated in Teamcenter 12.3. Use #PS_occ_eff_set_id instead.
|
|
@code
|
|
PS_occ_eff_set_id
|
|
@endcode
|
|
|
|
Sets the ID of the effectivity object.
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_set_id","PS_occ_eff_set_id")
|
|
extern CFM_API int CFM_effectivity_set_id(
|
|
tag_t eff_object, /**< (I) Tag of the effectivity object */
|
|
const char* id /**< (I) New ID for the effectivity object */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_ask_date_ranges deprecated in Teamcenter 12.3. Use #PS_occ_eff_ask_date_range instead.
|
|
@code
|
|
PS_occ_eff_ask_date_range
|
|
@endcode
|
|
|
|
Gives the list of effective date ranges on the effectivity object.
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_ask_date_ranges","PS_occ_eff_ask_date_range")
|
|
extern CFM_API int CFM_effectivity_ask_date_ranges(
|
|
tag_t eff_object, /**< (I) Tag of the effectivity object */
|
|
int* n_ranges, /**< (O) Number of date ranges attached to the effectivity object */
|
|
date_t** from_dates, /**< (OF) n_ranges List of "from" dates for the date ranges */
|
|
date_t** to_dates /**< (OF) n_ranges List of "to" dates for the date ranges */
|
|
);
|
|
|
|
/**
|
|
@deprecated #CFM_effectivity_set_date_ranges deprecated in Teamcenter 12.3. Use #PS_occ_eff_set_date_range instead.
|
|
|
|
@code
|
|
PS_occ_eff_set_date_range
|
|
@endcode
|
|
|
|
Sets the date ranges for the effectivity object, replacing all existing ranges on the object.
|
|
|
|
<b>Restrictions:</b>
|
|
|
|
Each date range range must be non-overlapping.
|
|
The final "to-date" may be #NULLDATE to represent an open-ended final range.
|
|
No other range may be open-ended
|
|
*/
|
|
TC_DEPRECATED("12.3","CFM_effectivity_set_date_ranges","PS_occ_eff_set_date_range")
|
|
extern CFM_API int CFM_effectivity_set_date_ranges(
|
|
tag_t eff_object, /**< (I) Tag of the effectivity object */
|
|
int n_ranges, /**< (I) Number of date ranges to attach to the effectivity object */
|
|
date_t* from_dates, /**< (I) List of "from" dates for the date ranges */
|
|
date_t* to_dates /**< (I) List of "to" dates for the date ranges */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
Create a new intent object
|
|
*/
|
|
extern CFM_API int CFM_create_intent(
|
|
const char* name, /**< (I) */
|
|
const char* desc, /**< (I) */
|
|
tag_t* new_intent /**< (O) */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/*================================================================================================*/
|
|
|
|
/**
|
|
@name Unified Effectivity
|
|
@{
|
|
*/
|
|
|
|
extern CFM_API int CFM_find_effectivities(
|
|
const char * id, /**< (I) */
|
|
int * n_effs, /**< (O) */
|
|
tag_t ** effs, /**< (OF) */
|
|
tag_t * date_info /**< (O) */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
@name Effectivity Mapping
|
|
@{
|
|
*/
|
|
|
|
extern CFM_API int CFM_create_eff_mapping(
|
|
tag_t itemrev, /**< (I) */
|
|
tag_t* mapping /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_eff(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t eff /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_eff_id(
|
|
tag_t mapping, /**< (I) */
|
|
const char * id /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_eff_protection(
|
|
tag_t mapping, /**< (I) */
|
|
logical protection /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_enditem(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t enditem /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_enditemrev(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t enditemrev /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_unit_range(
|
|
tag_t mapping, /**< (I) */
|
|
const char* range_text, /**< (I) */
|
|
logical append /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_units(
|
|
tag_t mapping, /**< (I) */
|
|
int n_units, /**< (I) */
|
|
int* start_end_values, /**< (I) n_units */
|
|
int open_ended_or_stock_out, /**< (I) */
|
|
logical append /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_date_range(
|
|
tag_t mapping, /**< (I) */
|
|
const char* range_text, /**< (I) */
|
|
logical append /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_dates(
|
|
tag_t mapping, /**< (I) */
|
|
int n_dates, /**< (I) */
|
|
date_t* start_end_values, /**< (I) n_dates */
|
|
int open_ended_or_stock_out, /**< (I) */
|
|
logical append /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_set_eff_mapping_subenditem(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t subenditem /**< (I) */
|
|
);
|
|
extern CFM_API int CFM_set_eff_mapping_subenditemrev(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t subenditemrev /**< (I) */
|
|
);
|
|
extern CFM_API int CFM_set_eff_mapping_subunit(
|
|
tag_t mapping, /**< (I) */
|
|
int subunit /**< (I) */
|
|
);
|
|
extern CFM_API int CFM_set_eff_mapping_subdate(
|
|
tag_t mapping, /**< (I) */
|
|
date_t subdate /**< (I) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_eff(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t * eff /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_eff_id(
|
|
tag_t mapping, /**< (I) */
|
|
char ** id /**< (OF) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_eff_protection(
|
|
tag_t mapping, /**< (I) */
|
|
logical * protection /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_enditem(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t * enditem /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_enditemrev(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t* enditemrev /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_range_type(
|
|
tag_t mapping, /**< (I) */
|
|
int* range_type /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_unit_range(
|
|
tag_t mapping, /**< (I) */
|
|
char** range_text /**< (OF) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_units(
|
|
tag_t mapping, /**< (I) */
|
|
int* n_units, /**< (O) */
|
|
int** start_end_values, /**< (OF) n_units */
|
|
int* open_ended_or_stock_out /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_date_range(
|
|
tag_t mapping, /**< (I) */
|
|
char** range_text /**< (OF) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_dates(
|
|
tag_t mapping, /**< (I) */
|
|
int* n_dates, /**< (O) */
|
|
date_t** start_end_values, /**< (OF) n_dates */
|
|
int* open_ended_or_stock_out /**< (O) */
|
|
);
|
|
|
|
extern CFM_API int CFM_ask_eff_mapping_subenditem(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t* subenditem /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_ask_eff_mapping_subenditemrev(
|
|
tag_t mapping, /**< (I) */
|
|
tag_t* subenditemrev /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_ask_eff_mapping_subunit(
|
|
tag_t mapping, /**< (I) */
|
|
int* subunit /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_ask_eff_mapping_subdate(
|
|
tag_t mapping, /**< (I) */
|
|
date_t* subdate /**< (O) */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
@name Revision Rule Modifiers
|
|
@{
|
|
*/
|
|
|
|
extern CFM_API int CFM_rule_modifier_ask_enditem(
|
|
tag_t modifier, /**< (I) */
|
|
tag_t* enditem /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_rule_modifier_ask_enditemrev(
|
|
tag_t modifier, /**< (I) */
|
|
tag_t* enditemrev /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_rule_modifier_ask_unit(
|
|
tag_t modifier, /**< (I) */
|
|
int* unit /**< (O) */
|
|
);
|
|
extern CFM_API int CFM_rule_modifier_ask_date(
|
|
tag_t modifier, /**< (I) */
|
|
date_t* date /**< (O) */
|
|
);
|
|
|
|
/** @} */
|
|
|
|
/*================================================================================================*/
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#include <cfm/libcfm_undef.h>
|
|
#endif
|