EIC code displayed by LXR master/​include/​opencascade/​IFSelect_WorkSession.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-10-03 09:16:22

 // Created on: 1992-12-15
 // Created by: Christian CAILLET
 // Copyright (c) 1992-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _IFSelect_WorkSession_HeaderFile
 #define _IFSelect_WorkSession_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_Type.hxx>
 
 #include <TCollection_AsciiString.hxx>
 #include <Interface_CheckIterator.hxx>
 #include <Standard_Transient.hxx>
 #include <NCollection_IndexedDataMap.hxx>
 #include <NCollection_DynamicArray.hxx>
 #include <NCollection_DataMap.hxx>
 #include <Standard_CString.hxx>
 #include <IFSelect_ReturnStatus.hxx>
 #include <Standard_Integer.hxx>
 #include <NCollection_Sequence.hxx>
 #include <NCollection_HSequence.hxx>
 #include <TCollection_HAsciiString.hxx>
 #include <IFSelect_RemainMode.hxx>
 #include <IFSelect_PrintCount.hxx>
 class IFSelect_ShareOut;
 class IFSelect_WorkLibrary;
 class Interface_Protocol;
 class Interface_InterfaceModel;
 class Interface_HGraph;
 class Interface_GTool;
 
 class IFSelect_ModelCopier;
 class IFSelect_Signature;
 class TCollection_HAsciiString;
 class Interface_Graph;
 class IFSelect_IntParam;
 class IFSelect_Selection;
 class Interface_EntityIterator;
 class IFSelect_SelectionIterator;
 class IFSelect_SignCounter;
 class IFSelect_Dispatch;
 class IFSelect_GeneralModifier;
 class IFSelect_Modifier;
 class IFSelect_Transformer;
 class IFSelect_PacketList;
 class IFSelect_SignatureList;
 
 //! This class can be used to simply manage a process such as
 //! splitting a file, extracting a set of Entities ...
 //! It allows to manage different types of Variables : Integer or
 //! Text Parameters, Selections, Dispatches, in addition to a
 //! ShareOut. To each of these variables, a unique Integer
 //! Identifier is attached. A Name can be attached too as desired.
 class IFSelect_WorkSession : public Standard_Transient
 {
 
 public:
   //! Creates a Work Session
   //! It provides default, empty ShareOut and ModelCopier, which can
   //! be replaced (if required, should be done just after creation).
   Standard_EXPORT IFSelect_WorkSession();
 
   //! Changes the Error Handler status (by default, it is not set)
   Standard_EXPORT void SetErrorHandle(const bool toHandle);
 
   //! Returns the Error Handler status
   bool ErrorHandle() const { return theerrhand; }
 
   //! Returns the ShareOut defined at creation time
   const occ::handle<IFSelect_ShareOut>& ShareOut() const { return theshareout; }
 
   //! Sets a new ShareOut. Fills Items which its content
   //! Warning : data from the former ShareOut are lost
   Standard_EXPORT void SetShareOut(const occ::handle<IFSelect_ShareOut>& shareout);
 
   //! Set value of mode responsible for presence of selections after loading
   //! If mode set to true that different selections will be accessible after loading
   //! else selections will be not accessible after loading( for economy memory in applications)
   void SetModeStat(const bool theMode) { themodelstat = theMode; }
 
   //! Return value of mode defining of filling selection during loading
   bool GetModeStat() const { return themodelstat; }
 
   //! Sets a WorkLibrary, which will be used to Read and Write Files
   void SetLibrary(const occ::handle<IFSelect_WorkLibrary>& theLib) { thelibrary = theLib; }
 
   //! Returns the WorkLibrary. Null Handle if not yet set
   //! should be C++ : return const &
   const occ::handle<IFSelect_WorkLibrary>& WorkLibrary() const { return thelibrary; }
 
   //! Sets a Protocol, which will be used to determine Graphs, to
   //! Read and to Write Files
   Standard_EXPORT void SetProtocol(const occ::handle<Interface_Protocol>& protocol);
 
   //! Returns the Protocol. Null Handle if not yet set
   //! should be C++ : return const &
   const occ::handle<Interface_Protocol>& Protocol() const { return theprotocol; }
 
   //! Sets a specific Signature to be the SignType, i.e. the
   //! Signature which will determine TypeName from the Model
   //! (basic function). It is recorded in the GTool
   //! This Signature is also set as "xst-sign-type" (reserved name)
   Standard_EXPORT void SetSignType(const occ::handle<IFSelect_Signature>& signtype);
 
   //! Returns the current SignType
   Standard_EXPORT occ::handle<IFSelect_Signature> SignType() const;
 
   //! Returns True is a Model has been set
   bool HasModel() const { return (!myModel.IsNull()); }
 
   //! Sets a Model as input : this will be the Model from which the
   //! ShareOut will work
   //! if <clearpointed> is True (default) all SelectPointed items
   //! are cleared, else they must be managed by the caller
   //! Remark : SetModel clears the Graph, recomputes it if a
   //! Protocol is set and if the Model is not empty, of course
   Standard_EXPORT void SetModel(const occ::handle<Interface_InterfaceModel>& model,
                                 const bool                                   clearpointed = true);
 
   //! Returns the Model of the Work Session (Null Handle if none)
   //! should be C++ : return const &
   const occ::handle<Interface_InterfaceModel>& Model() const { return myModel; }
 
   //! Stores the filename used for read for setting the model
   //! It is cleared by SetModel and ClearData(1)
   void SetLoadedFile(const char* const theFileName) { theloaded = theFileName; }
 
   //! Returns the filename used to load current model
   //! empty if unknown
   const char* LoadedFile() const { return theloaded.ToCString(); }
 
   //! Reads a file with the WorkLibrary (sets Model and LoadedFile)
   //! Returns a integer status which can be :
   //! RetDone if OK, RetVoid if no Protocol not defined,
   //! RetError for file not found, RetFail if fail during read
   Standard_EXPORT IFSelect_ReturnStatus ReadFile(const char* const filename);
 
   //! Reads a file from stream with the WorkLibrary (sets Model and LoadedFile)
   //! Returns a integer status which can be :
   //! RetDone if OK, RetVoid if no Protocol not defined,
   //! RetError for file not found, RetFail if fail during read
   Standard_EXPORT IFSelect_ReturnStatus ReadStream(const char* const theName,
                                                    std::istream&     theIStream);
 
   //! Returns the count of Entities stored in the Model, or 0
   Standard_EXPORT int NbStartingEntities() const;
 
   //! Returns an Entity stored in the Model of the WorkSession
   //! (Null Handle is no Model or num out of range)
   Standard_EXPORT occ::handle<Standard_Transient> StartingEntity(const int num) const;
 
   //! Returns the Number of an Entity in the Model
   //! (0 if no Model set or <ent> not in the Model)
   Standard_EXPORT int StartingNumber(const occ::handle<Standard_Transient>& ent) const;
 
   //! From a given label in Model, returns the corresponding number
   //! Starts from first entity by Default, may start after a given
   //! number : this number may be given negative, its absolute value
   //! is then considered. Hence a loop on NumberFromLabel may be
   //! programmed (stop test is : returned value positive or null)
   //!
   //! Returns 0 if not found, < 0 if more than one found (first
   //! found in negative).
   //! If <val> just gives an integer value, returns it
   Standard_EXPORT int NumberFromLabel(const char* const val, const int afternum = 0) const;
 
   //! Returns the label for <ent>, as the Model does
   //! If <ent> is not in the Model or if no Model is loaded, a Null
   //! Handle is returned
   Standard_EXPORT occ::handle<TCollection_HAsciiString> EntityLabel(
     const occ::handle<Standard_Transient>& ent) const;
 
   //! Returns the Name of an Entity
   //! This Name is computed by the general service Name
   //! Returns a Null Handle if fails
   Standard_EXPORT occ::handle<TCollection_HAsciiString> EntityName(
     const occ::handle<Standard_Transient>& ent) const;
 
   //! Returns the Category Number determined for an entity
   //! it is computed by the class Category
   //! An unknown entity (number 0) gives a value -1
   Standard_EXPORT int CategoryNumber(const occ::handle<Standard_Transient>& ent) const;
 
   //! Returns the Category Name determined for an entity
   //! it is computed by the class Category
   //! Remark : an unknown entity gives an empty string
   Standard_EXPORT const char* CategoryName(const occ::handle<Standard_Transient>& ent) const;
 
   //! Returns the Validity Name determined for an entity
   //! it is computed by the class SignValidity
   //! Remark : an unknown entity gives an empty string
   Standard_EXPORT const char* ValidityName(const occ::handle<Standard_Transient>& ent) const;
 
   //! Clears recorded data (not the items) according mode :
   //! 1 : all Data : Model, Graph, CheckList, + ClearData 4
   //! 2 : Graph and CheckList (they will then be recomputed later)
   //! 3 : CheckList (it will be recomputed by ComputeCheck)
   //! 4 : just content of SelectPointed and Counters
   //! Plus 0 : does nothing but called by SetModel
   //! ClearData is virtual, hence it can be redefined to clear
   //! other data of a specialised Work Session
   Standard_EXPORT virtual void ClearData(const int mode);
 
   //! Computes the Graph used for Selections, Displays ...
   //! If a HGraph is already set, with same model as given by method
   //! Model, does nothing. Else, computes a new Graph.
   //! If <enforce> is given True, computes a new Graph anyway.
   //! Remark that a call to ClearGraph will cause ComputeGraph to
   //! really compute a new Graph
   //! Returns True if Graph is OK, False else (i.e. if no Protocol
   //! is set, or if Model is absent or empty).
   Standard_EXPORT bool ComputeGraph(const bool enforce = false);
 
   //! Returns the Computed Graph as HGraph (Null Handle if not set)
   Standard_EXPORT occ::handle<Interface_HGraph> HGraph();
 
   //! Returns the Computed Graph, for Read only
   Standard_EXPORT const Interface_Graph& Graph();
 
   //! Returns the list of entities shared by <ent> (can be empty)
   //! Returns a null Handle if <ent> is unknown
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> Shareds(
     const occ::handle<Standard_Transient>& ent);
 
   //! Returns the list of entities sharing <ent> (can be empty)
   //! Returns a null Handle if <ent> is unknown
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> Sharings(
     const occ::handle<Standard_Transient>& ent);
 
   //! Returns True if a Model is defined and really loaded (not
   //! empty), a Protocol is set and a Graph has been computed.
   //! In this case, the WorkSession can start to work
   Standard_EXPORT bool IsLoaded() const;
 
   //! Computes the CheckList for the Model currently loaded
   //! It can then be used for displays, queries ...
   //! Returns True if OK, False else (i.e. no Protocol set, or Model
   //! absent). If <enforce> is False, works only if not already done
   //! or if a new Model has been loaded from last call.
   //! Remark : computation is enforced by every call to
   //! SetModel or RunTransformer
   Standard_EXPORT bool ComputeCheck(const bool enforce = false);
 
   //! Returns the Check List for the Model currently loaded :
   //! <complete> = True  : complete (syntactic & semantic messages),
   //! computed if not yet done
   //! <complete> = False : only syntactic (check file form)
   Standard_EXPORT Interface_CheckIterator ModelCheckList(const bool complete = true);
 
   //! Returns a Check for a single entity, under the form of a
   //! CheckIterator (this gives only one form for the user)
   //! if <ent> is Null or equates the current Model, it gives the
   //! Global Check, else the Check for the given entity
   //! <complete> as for ModelCheckList
   Standard_EXPORT Interface_CheckIterator CheckOne(const occ::handle<Standard_Transient>& ent,
                                                    const bool complete = true);
 
   //! Returns the Check List produced by the last execution of
   //! either : EvaluateFile(for Split), SendSplit, SendAll,
   //! SendSelected, RunTransformer-RunModifier
   //! Cleared by SetModel or ClearData(1)
   //! The field is protected, hence a specialized WorkSession may
   //! fill it
   Interface_CheckIterator LastRunCheckList() const { return thecheckrun; }
 
   //! Returns the Maximum Value for an Item Identifier. It can be
   //! greater to the count of known Items, because some can have
   //! been removed
   Standard_EXPORT int MaxIdent() const;
 
   //! Returns an Item, given its Ident. Returns a Null Handle if
   //! no Item corresponds to this Ident.
   Standard_EXPORT occ::handle<Standard_Transient> Item(const int id) const;
 
   //! Returns the Ident attached to an Item in the WorkSession, or
   //! Zero if it is unknown
   Standard_EXPORT int ItemIdent(const occ::handle<Standard_Transient>& item) const;
 
   //! Returns the Item which corresponds to a Variable, given its
   //! Name (whatever the type of this Item).
   //! Returns a Null Handle if this Name is not recorded
   Standard_EXPORT occ::handle<Standard_Transient> NamedItem(const char* const name) const;
 
   //! Same as above, but <name> is given through a Handle
   //! Especially useful with methods SelectionNames, etc...
   Standard_EXPORT occ::handle<Standard_Transient> NamedItem(
     const occ::handle<TCollection_HAsciiString>& name) const;
 
   //! Returns the Ident attached to a Name, 0 if name not recorded
   Standard_EXPORT int NameIdent(const char* const name) const;
 
   //! Returns True if an Item of the WorkSession has an attached Name
   Standard_EXPORT bool HasName(const occ::handle<Standard_Transient>& item) const;
 
   //! Returns the Name attached to an Item as a Variable of this
   //! WorkSession. If <item> is Null or not recorded, returns an
   //! empty string.
   Standard_EXPORT occ::handle<TCollection_HAsciiString> Name(
     const occ::handle<Standard_Transient>& item) const;
 
   //! Adds an Item and returns its attached Ident. Does nothing
   //! if <item> is already recorded (and returns its attached Ident)
   //! <active> if True commands call to SetActive (see below)
   //! Remark : the determined Ident is used if <item> is a Dispatch,
   //! to fill the ShareOut
   Standard_EXPORT int AddItem(const occ::handle<Standard_Transient>& item,
                               const bool                             active = true);
 
   //! Adds an Item with an attached Name. If the Name is already
   //! known in the WorkSession, the older item losts it
   //! Returns Ident if Done, 0 else, i.e. if <item> is null
   //! If <name> is empty, works as AddItem (i.e. with no name)
   //! If <item> is already known but with no attached Name, this
   //! method tries to attached a Name to it
   //! <active> if True commands call to SetActive (see below)
   Standard_EXPORT int AddNamedItem(const char* const                      name,
                                    const occ::handle<Standard_Transient>& item,
                                    const bool                             active = true);
 
   //! Following the type of <item> :
   //! - Dispatch : Adds or Removes it in the ShareOut & FileNaming
   //! - GeneralModifier : Adds or Removes it for final sending
   //! (i.e. in the ModelCopier)
   //! Returns True if it did something, False else (state unchanged)
   Standard_EXPORT bool SetActive(const occ::handle<Standard_Transient>& item, const bool mode);
 
   //! Removes an Item from the Session, given its Name
   //! Returns True if Done, False else (Name not recorded)
   //! (Applies only on Item which are Named)
   Standard_EXPORT bool RemoveNamedItem(const char* const name);
 
   //! Removes a Name without removing the Item
   //! Returns True if Done, False else (Name not recorded)
   Standard_EXPORT bool RemoveName(const char* const name);
 
   //! Removes an Item given its Ident. Returns False if <id> is
   //! attached to no Item in the WorkSession. For a Named Item,
   //! also removes its Name.
   Standard_EXPORT bool RemoveItem(const occ::handle<Standard_Transient>& item);
 
   //! Clears all the recorded Items : Selections, Dispatches,
   //! Modifiers, and Strings & IntParams, with their Idents & Names.
   //! Remark that if a Model has been loaded, it is not cleared.
   Standard_EXPORT void ClearItems();
 
   //! Returns a Label which illustrates the content of an Item,
   //! given its Ident. This Label is :
   //! - for a Text Parameter, "Text:<text value>"
   //! - for an Integer Parameter, "Integer:<integer value>"
   //! - for a Selection, a Dispatch or a Modifier, its Label
   //! (see these classes)
   //! - for any other kind of Variable, its cdl type
   Standard_EXPORT occ::handle<TCollection_HAsciiString> ItemLabel(const int id) const;
 
   //! Fills a Sequence with the List of Idents attached to the Items
   //! of which Type complies with (IsKind) <type> (alphabetic order)
   //! Remark : <type> = TYPE(Standard_Transient) gives all the
   //! Idents which are suitable in the WorkSession
   Standard_EXPORT occ::handle<NCollection_HSequence<int>> ItemIdents(
     const occ::handle<Standard_Type>& type) const;
 
   //! Fills a Sequence with the list of the Names attached to Items
   //! of which Type complies with (IsKind) <type> (alphabetic order)
   //! Remark : <type> = TYPE(Standard_Transient) gives all the Names
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>>
                   ItemNames(const occ::handle<Standard_Type>& type) const;
 
   //! Fills a Sequence with the NAMES of the control items, of which
   //! the label matches <label> (contain it) : see NextIdentForLabel
   //! Search mode is fixed to "contained"
   //! If <label> is empty, returns all Names
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>>
                   ItemNamesForLabel(const char* const label) const;
 
   //! For query by Label with possible iterations
   //! Searches the Ident of which Item has a Label which matches a
   //! given one, the search starts from an initial Ident.
   //! Returns the first found Ident which follows <id>, or ZERO
   //!
   //! The search must start with <id> = 0, it returns the next Ident
   //! which matches. To iterate, call again this method which this
   //! returned value as <id>. Once an Ident has been returned, the
   //! Item can be obtained by the method Item
   //!
   //! <mode> precises the required matching mode :
   //! - 0 (Default) : <label> must match exactly with the Item Label
   //! - 1 : <label> must match the exact beginning (the end is free)
   //! - 2 : <label> must be at least once wherever in the Item Label
   //! - other values are ignored
   Standard_EXPORT int NextIdentForLabel(const char* const label,
                                         const int         id,
                                         const int         mode = 0) const;
 
   //! Creates a parameter as being bound to a Static
   //! If the Static is Integer, this creates an IntParam bound to
   //! it by its name. Else this creates a String which is the value
   //! of the Static.
   //! Returns a null handle if <statname> is unknown as a Static
   Standard_EXPORT occ::handle<Standard_Transient> NewParamFromStatic(const char* const statname,
                                                                      const char* const name = "");
 
   //! Returns an IntParam, given its Ident in the Session
   //! Null result if <id> is not suitable for an IntParam
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_IntParam> IntParam(const int id) const;
 
   //! Returns Integer Value of an IntParam
   Standard_EXPORT int IntValue(const occ::handle<IFSelect_IntParam>& it) const;
 
   //! Creates a new IntParam. A Name can be set (Optional)
   //! Returns the created IntParam, or a Null Handle in case of
   //! Failure (see AddItem/AddNamedItem)
   Standard_EXPORT occ::handle<IFSelect_IntParam> NewIntParam(const char* const name = "");
 
   //! Changes the Integer Value of an IntParam
   //! Returns True if Done, False if <it> is not in the WorkSession
   Standard_EXPORT bool SetIntValue(const occ::handle<IFSelect_IntParam>& it, const int val);
 
   //! Returns a TextParam, given its Ident in the Session
   //! Null result if <id> is not suitable for a TextParam
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<TCollection_HAsciiString> TextParam(const int id) const;
 
   //! Returns Text Value of a TextParam (a String)
   //! or an empty string if <it> is not in the WorkSession
   Standard_EXPORT TCollection_AsciiString
     TextValue(const occ::handle<TCollection_HAsciiString>& par) const;
 
   //! Creates a new (empty) TextParam. A Name can be set (Optional)
   //! Returns the created TextParam (as an HAsciiString), or a Null
   //! Handle in case of Failure (see AddItem/AddNamedItem)
   Standard_EXPORT occ::handle<TCollection_HAsciiString> NewTextParam(const char* const name = "");
 
   //! Changes the Text Value of a TextParam (an HAsciiString)
   //! Returns True if Done, False if <it> is not in the WorkSession
   Standard_EXPORT bool SetTextValue(const occ::handle<TCollection_HAsciiString>& par,
                                     const char* const                            val);
 
   //! Returns a Signature, given its Ident in the Session
   //! Null result if <id> is not suitable for a Signature
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_Signature> Signature(const int id) const;
 
   //! Returns the Value computed by a Signature for an Entity
   //! Returns an empty string if the entity does not belong to the
   //! loaded model
   Standard_EXPORT const char* SignValue(const occ::handle<IFSelect_Signature>& sign,
                                         const occ::handle<Standard_Transient>& ent) const;
 
   //! Returns a Selection, given its Ident in the Session
   //! Null result if <id> is not suitable for a Selection
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_Selection> Selection(const int id) const;
 
   //! Evaluates the effect of a Selection applied on the input Model
   //! Returned Result remains empty if no input Model has been set
   Standard_EXPORT Interface_EntityIterator
     EvalSelection(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Returns the Selections which are source of Selection, given
   //! its rank in the List of Selections (see SelectionIterator)
   //! Returned value is empty if <num> is out of range or if
   //! <sel> is not in the WorkSession
   Standard_EXPORT IFSelect_SelectionIterator
     Sources(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Returns the result of a Selection, computed by EvalSelection
   //! (see above) under the form of a HSequence (hence, it can be
   //! used by a frontal-engine logic). It can be empty
   //! Returns a Null Handle if <sel> is not in the WorkSession
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>
                   SelectionResult(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Returns the result of a Selection, by forcing its input with
   //! a given list <list> (unless <list> is Null).
   //! RULES :
   //! <list> applies only for a SelectDeduct kind Selection :
   //! its Input is considered : if it is a SelectDeduct kind
   //! Selection, its Input is considered, etc... until an Input
   //! is not a Deduct/Extract : its result is replaced by <list>
   //! and all the chain of deductions is applied
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>
                   SelectionResultFromList(
                     const occ::handle<IFSelect_Selection>&                                     sel,
                     const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& list) const;
 
   //! Sets a Selection as input for an item, according its type :
   //! if <item> is a Dispatch : as Final Selection
   //! if <item> is a GeneralModifier (i.e. any kind of Modifier) :
   //! as Selection used to filter entities to modify
   //! <sel> Null causes this Selection to be nullified
   //! Returns False if <item> is not of a suitable type, or
   //! <item> or <sel> is not in the WorkSession
   Standard_EXPORT bool SetItemSelection(const occ::handle<Standard_Transient>& item,
                                         const occ::handle<IFSelect_Selection>& sel);
 
   //! Resets input Selection which was set by SetItemSelection
   //! Same conditions as for SetItemSelection
   //! Returns True if done, False if <item> is not in the WorkSession
   Standard_EXPORT bool ResetItemSelection(const occ::handle<Standard_Transient>& item);
 
   //! Returns the Selection of a Dispatch or a GeneralModifier.
   //! Returns a Null Handle if none is defined or <item> not good type
   Standard_EXPORT occ::handle<IFSelect_Selection> ItemSelection(
     const occ::handle<Standard_Transient>& item) const;
 
   //! Returns a SignCounter from its ident in the Session
   //! Null result if <id> is not suitable for a SignCounter
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_SignCounter> SignCounter(const int id) const;
 
   //! Computes the content of a SignCounter when it is defined with
   //! a Selection, then returns True
   //! Returns False if the SignCounter is not defined with a
   //! Selection, or if its Selection Mode is inhibited
   //! <forced> to work around optimisations
   Standard_EXPORT bool ComputeCounter(const occ::handle<IFSelect_SignCounter>& counter,
                                       const bool                               forced = false);
 
   //! Computes the content of a SignCounter from an input list
   //! If <list> is Null, uses internal definition of the Counter :
   //! a Selection, else the whole Model (recomputation forced)
   //! If <clear> is True (D), starts from scratch
   //! Else, cumulates computations
   Standard_EXPORT bool ComputeCounterFromList(
     const occ::handle<IFSelect_SignCounter>&                                   counter,
     const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& list,
     const bool                                                                 clear = true);
 
   //! Returns the ordered list of dispatches stored by the ShareOut
   Standard_EXPORT occ::handle<NCollection_HSequence<int>> AppliedDispatches() const;
 
   //! Clears the list of Dispatches recorded by the ShareOut
   //! if <only> disp is True, tha's all. Else, clears also the lists
   //! of Modifiers recorded by the ShareOut
   Standard_EXPORT void ClearShareOut(const bool onlydisp);
 
   //! Returns a Dispatch, given its Ident in the Session
   //! Null result if <id> is not suitable for a Dispatch
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_Dispatch> Dispatch(const int id) const;
 
   //! Returns the rank of a Dispatch in the ShareOut, or 0 if <disp>
   //! is not in the ShareOut or not in the WorkSession
   Standard_EXPORT int DispatchRank(const occ::handle<IFSelect_Dispatch>& disp) const;
 
   //! Gives access to the complete ModelCopier
   const occ::handle<IFSelect_ModelCopier>& ModelCopier() const { return thecopier; }
 
   //! Sets a new ModelCopier. Fills Items which its content
   Standard_EXPORT void SetModelCopier(const occ::handle<IFSelect_ModelCopier>& copier);
 
   //! Returns the count of Modifiers applied to final sending
   //! Model Modifiers if <formodel> is True, File Modifiers else
   //! (i.e. Modifiers which apply once the Models have been filled)
   Standard_EXPORT int NbFinalModifiers(const bool formodel) const;
 
   //! Fills a Sequence with a list of Idents, those attached to
   //! the Modifiers applied to final sending.
   //! Model Modifiers if <formodel> is True, File Modifiers else
   //! This list is given in the order in which they will be applied
   //! (which takes into account the Changes to Modifier Ranks)
   Standard_EXPORT occ::handle<NCollection_HSequence<int>> FinalModifierIdents(
     const bool formodel) const;
 
   //! Returns a Modifier, given its Ident in the Session
   //! Null result if <id> is not suitable for a Modifier
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_GeneralModifier> GeneralModifier(const int id) const;
 
   //! Returns a Model Modifier, given its Ident in the Session,
   //! i.e. typed as a Modifier (not simply a GeneralModifier)
   //! Null result if <id> is not suitable for a Modifier
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_Modifier> ModelModifier(const int id) const;
 
   //! Returns the Rank of a Modifier given its Ident. Model or File
   //! Modifier according its type (ModelModifier or not)
   //! Remember that Modifiers are applied sequentially following
   //! their Rank : first Model Modifiers then File Modifiers
   //! Rank is given by rank of call to AddItem and can be
   //! changed by ChangeModifierRank
   Standard_EXPORT int ModifierRank(const occ::handle<IFSelect_GeneralModifier>& item) const;
 
   //! Changes the Rank of a Modifier in the Session :
   //! Model Modifiers if <formodel> is True, File Modifiers else
   //! the Modifier n0 <before> is put to n0 <after>
   //! Return True if Done, False if <before> or <after> out of range
   Standard_EXPORT bool ChangeModifierRank(const bool formodel, const int before, const int after);
 
   //! Removes all the Modifiers active in the ModelCopier : they
   //! become inactive and they are removed from the Session
   Standard_EXPORT void ClearFinalModifiers();
 
   //! Sets a GeneralModifier to be applied to an item :
   //! - item = ShareOut : applies for final sending (all dispatches)
   //! - item is a Dispatch : applies for this dispatch only
   //! Returns True if done, False if <modif> or <item> not in <me>
   Standard_EXPORT bool SetAppliedModifier(const occ::handle<IFSelect_GeneralModifier>& modif,
                                           const occ::handle<Standard_Transient>&       item);
 
   //! Resets a GeneralModifier to be applied
   //! Returns True if done, False if <modif> was not applied
   Standard_EXPORT bool ResetAppliedModifier(const occ::handle<IFSelect_GeneralModifier>& modif);
 
   //! Returns the item on which a GeneralModifier is applied :
   //! the ShareOut, or a given Dispatch
   //! Returns a Null Handle if <modif> is not applied
   Standard_EXPORT occ::handle<Standard_Transient> UsesAppliedModifier(
     const occ::handle<IFSelect_GeneralModifier>& modif) const;
 
   //! Returns a Transformer, given its Ident in the Session
   //! Null result if <id> is not suitable for a Transformer
   //! (undefined, or defined for another kind of variable)
   Standard_EXPORT occ::handle<IFSelect_Transformer> Transformer(const int id) const;
 
   //! Runs a Transformer on starting Model, which can then be edited
   //! or replaced by a new one. The Protocol can also be changed.
   //! Fills LastRunCheckList
   //!
   //! Returned status is 0 if nothing done (<transf> or model
   //! undefined), positive if OK, negative else :
   //! 0  : Nothing done
   //! 1  : OK, edition on the spot with no change to the graph
   //! of dependencies (purely local)
   //! 2  : OK, model edited on the spot (graph recomputed, may
   //! have changed), protocol unchanged
   //! 3  : OK, new model produced, same protocol
   //! 4  : OK, model edited on the spot (graph recomputed),
   //! but protocol has changed
   //! 5  : OK, new model produced, protocol has changed
   //! -1 : Error on the spot (slight changes), data may be corrupted
   //! (remark : corruption should not be profound)
   //! -2 : Error on edition the spot, data may be corrupted
   //! (checking them is recommended)
   //! -3 : Error with a new data set, transformation ignored
   //! -4 : OK as 4, but graph of dependences count not be recomputed
   //! (the former one is kept) : check the protocol
   Standard_EXPORT int RunTransformer(const occ::handle<IFSelect_Transformer>& transf);
 
   //! Runs a Modifier on Starting Model. It can modify entities, or
   //! add new ones. But the Model or the Protocol is unchanged.
   //! The Modifier is applied on each entity of the Model. See also
   //! RunModifierSelected
   //! Fills LastRunCheckList
   //!
   //! <copy> : if True, a new data set is produced which brings
   //! the modifications (Model + its Entities)
   //! if False, data are modified on the spot
   //!
   //! It works through a TransformStandard defined with <modif>
   //! Returned status as RunTransformer : 0 nothing done, >0 OK,
   //! <0 problem, but only between -3 and 3 (protocol unchanged)
   //! Remark : <copy> True will give <effect> = 3 or -3
   Standard_EXPORT int RunModifier(const occ::handle<IFSelect_Modifier>& modif, const bool copy);
 
   //! Acts as RunModifier, but the Modifier is applied on the list
   //! determined by a Selection, rather than on the whole Model
   //! If the selection is a null handle, the whole model is taken
   Standard_EXPORT int RunModifierSelected(const occ::handle<IFSelect_Modifier>&  modif,
                                           const occ::handle<IFSelect_Selection>& sel,
                                           const bool                             copy);
 
   //! Creates and returns a TransformStandard, empty, with its
   //! Copy Option (True = Copy, False = On the Spot) and an
   //! optional name.
   //! To a TransformStandard, the method SetAppliedModifier applies
   Standard_EXPORT occ::handle<IFSelect_Transformer> NewTransformStandard(
     const bool        copy,
     const char* const name = "");
 
   //! Defines a new content from the former one
   //! If <keep> is True, it is given by entities selected by
   //! Selection <sel> (and all shared entities)
   //! Else, it is given by all the former content but entities
   //! selected by the Selection <sel> (and properly shared ones)
   //! Returns True if done. Returns False if the selected list
   //! (from <sel>) is empty, hence nothing is done
   Standard_EXPORT bool SetModelContent(const occ::handle<IFSelect_Selection>& sel, const bool keep);
 
   //! Returns the defined File Prefix. Null Handle if not defined
   Standard_EXPORT occ::handle<TCollection_HAsciiString> FilePrefix() const;
 
   //! Returns the defined Default File Root. It is used for
   //! Dispatches which have no specific root attached.
   //! Null Handle if not defined
   Standard_EXPORT occ::handle<TCollection_HAsciiString> DefaultFileRoot() const;
 
   //! Returns the defined File Extension. Null Handle if not defined
   Standard_EXPORT occ::handle<TCollection_HAsciiString> FileExtension() const;
 
   //! Returns the File Root defined for a Dispatch. Null if no
   //! Root Name is defined for it (hence, no File will be produced)
   Standard_EXPORT occ::handle<TCollection_HAsciiString> FileRoot(
     const occ::handle<IFSelect_Dispatch>& disp) const;
 
   //! Defines a File Prefix
   Standard_EXPORT void SetFilePrefix(const char* const name);
 
   //! Defines a Default File Root Name. Clears it is <name> = ""
   //! Returns True if OK, False if <name> already set for a Dispatch
   Standard_EXPORT bool SetDefaultFileRoot(const char* const name);
 
   //! Defines a File Extension
   Standard_EXPORT void SetFileExtension(const char* const name);
 
   //! Defines a Root for a Dispatch
   //! If <name> is empty, clears Root Name
   //! This has as effect to inhibit the production of File by <disp>
   //! Returns False if <disp> is not in the WorkSession or if a
   //! root name is already defined for it
   Standard_EXPORT bool SetFileRoot(const occ::handle<IFSelect_Dispatch>& disp,
                                    const char* const                     name);
 
   //! Extracts File Root Name from a given complete file name
   //! (uses OSD_Path)
   Standard_EXPORT const char* GiveFileRoot(const char* const file) const;
 
   //! Completes a file name as required, with Prefix and Extension
   //! (if defined; for a non-defined item, completes nothing)
   Standard_EXPORT const char* GiveFileComplete(const char* const file) const;
 
   //! Erases all stored data from the File Evaluation
   //! (i.e. ALL former naming information are lost)
   Standard_EXPORT void ClearFile();
 
   //! Performs and stores a File Evaluation. The Results are a List
   //! of produced Models and a List of names (Strings), in parallel
   //! Fills LastRunCheckList
   Standard_EXPORT void EvaluateFile();
 
   //! Returns the count of produced Models
   Standard_EXPORT int NbFiles() const;
 
   //! Returns a Model, given its rank in the Evaluation List
   Standard_EXPORT occ::handle<Interface_InterfaceModel> FileModel(const int num) const;
 
   //! Returns the name of a file corresponding to a produced Model,
   //! given its rank in the Evaluation List
   Standard_EXPORT TCollection_AsciiString FileName(const int num) const;
 
   //! Commands file sending to clear the list of already sent files,
   //! commands to record a new one if <record> is True
   //! This list is managed by the ModelCopier when SendSplit is called
   //! It allows a global exploitation of the set of sent files
   Standard_EXPORT void BeginSentFiles(const bool record);
 
   //! Returns the list of recorded sent files, or a Null Handle is
   //! recording has not been enabled
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>>
                   SentFiles() const;
 
   //! Performs creation of derived files from the input Model
   //! Takes its data (sub-models and names), from result EvaluateFile
   //! if active, else by dynamic Evaluation (not stored)
   //! After SendSplit, result of EvaluateFile is Cleared
   //! Fills LastRunCheckList
   //!
   //! Works with the WorkLibrary which acts on specific type of Model
   //! and can work with File Modifiers (managed by the Model Copier)
   //! and a ModelCopier, which can work with Model Modifiers
   //! Returns False if, either WorkLibrary has failed on at least
   //! one sub-file, or the Work Session is badly conditioned
   //! (no Model defined, or FileNaming not in phase with ShareOut)
   Standard_EXPORT bool SendSplit();
 
   //! Returns an Evaluation of the whole ShareOut definition : i.e.
   //! how the entities of the starting model are forecast to be sent
   //! to various files : list of packets according the dispatches,
   //! effective lists of roots for each packet (which determine the
   //! content of the corresponding file); plus evaluation of which
   //! entities are : forgotten (sent into no file), duplicated (sent
   //! into more than one file), sent into a given file.
   //! See the class PacketList for more details.
   Standard_EXPORT occ::handle<IFSelect_PacketList> EvalSplit() const;
 
   //! Returns the list of Entities sent in files, according to the
   //! count of files each one has been sent (these counts are reset
   //! by SetModel or SetRemaining(Forget) ) stored in Graph Status
   //! <count> = -1 (default) is for ENtities sent at least once
   //! <count> = 0 is for the Remaining List (entities not yet sent)
   //! <count> = 1 is for entities sent in one and only one file
   //! (the ideal case)
   //! Remaining Data are computed on each Sending/Copying output
   //! files (see methods EvaluateFile and SendSplit)
   //! Graph Status is 0 for Remaining Entity, <count> for Sent into
   //! <count> files
   //! This status is set to 0 (not yet sent) for all by SetModel
   //! and by SetRemaining(mode=Forget,Display)
   Standard_EXPORT Interface_EntityIterator SentList(const int count = -1) const;
 
   //! Returns the greater count of different files in which any of
   //! the starting entities could be sent.
   //! Before any file output, this count is 0.
   //! Ideal count is 1. More than 1 means that duplications occur.
   Standard_EXPORT int MaxSendingCount() const;
 
   //! Processes Remaining data (after having sent files), mode :
   //! Forget  : forget remaining info (i.e. clear all "Sent" status)
   //! Compute : compute and keep remaining (does nothing if :
   //! remaining is empty or if no files has been sent)
   //! Display : display entities recorded as remaining
   //! Undo    : restore former state of data (after Remaining(1) )
   //! Returns True if OK, False else (i.e. mode = 2 and Remaining
   //! List is either empty or takes all the entities, or mode = 3
   //! and no former computation of remaining data was done)
   Standard_EXPORT bool SetRemaining(const IFSelect_RemainMode mode);
 
   //! Sends the starting Model into one file, without splitting,
   //! managing remaining data or anything else.
   //! <computegraph> true commands the Graph to be recomputed before
   //! sending : required when a Model is filled in several steps
   //!
   //! The Model and File Modifiers recorded to be applied on sending
   //! files are.
   //! Returns a status of execution :
   //! Done if OK,
   //! Void if no data available,
   //! Error if errors occurred (work library is not defined), errors during translation
   //! Fail if exception during translation is raised
   //! Stop if no disk space or disk, file is write protected
   //! Fills LastRunCheckList
   Standard_EXPORT IFSelect_ReturnStatus SendAll(const char* const filename,
                                                 const bool        computegraph = false);
 
   //! Sends a part of the starting Model into one file, without
   //! splitting. But remaining data are managed.
   //! <computegraph> true commands the Graph to be recomputed before
   //! sending : required when a Model is filled in several steps
   //!
   //! The Model and File Modifiers recorded to be applied on sending
   //! files are.
   //! Returns a status : Done if OK, Fail if error during send,
   //! Error : WorkLibrary not defined, Void : selection list empty
   //! Fills LastRunCheckList
   Standard_EXPORT IFSelect_ReturnStatus SendSelected(const char* const filename,
                                                      const occ::handle<IFSelect_Selection>& sel,
                                                      const bool computegraph = false);
 
   //! Writes the current Interface Model globally to a File, and
   //! returns a write status which can be :
   //! Done OK, Fail file could not be written, Error no norm is selected
   //! Remark : It is a simple, one-file writing, other operations are
   //! available (such as splitting ...) which calls SendAll
   Standard_EXPORT IFSelect_ReturnStatus WriteFile(const char* const filename);
 
   //! Writes a sub-part of the current Interface Model to a File,
   //! as defined by a Selection <sel>, recomputes the Graph, and
   //! returns a write status which can be :
   //! Done OK, Fail file could not be written, Error no norm is selected
   //! Remark : It is a simple, one-file writing, other operations are
   //! available (such as splitting ...) which calls SendSelected
   Standard_EXPORT IFSelect_ReturnStatus WriteFile(const char* const                      filename,
                                                   const occ::handle<IFSelect_Selection>& sel);
 
   //! Returns the count of Input Selections known for a Selection,
   //! or 0 if <sel> not in the WorkSession. This count is one for a
   //! SelectDeduct / SelectExtract kind, two for SelectControl kind,
   //! variable for a SelectCombine (Union/Intersection), zero else
   Standard_EXPORT int NbSources(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Returns the <num>th Input Selection of a Selection
   //! (see NbSources).
   //! Returns a Null Handle if <sel> is not in the WorkSession or if
   //! <num> is out of the range <1-NbSources>
   //! To obtain more details, see the method Sources
   Standard_EXPORT occ::handle<IFSelect_Selection> Source(const occ::handle<IFSelect_Selection>& sel,
                                                          const int num = 1) const;
 
   //! Returns True if <sel> a Reversed SelectExtract, False else
   Standard_EXPORT bool IsReversedSelectExtract(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Toggles the Sense (Direct <-> Reversed) of a SelectExtract
   //! Returns True if Done, False if <sel> is not a SelectExtract or
   //! is not in the WorkSession
   Standard_EXPORT bool ToggleSelectExtract(const occ::handle<IFSelect_Selection>& sel);
 
   //! Sets an Input Selection (as <input>) to a SelectExtract or
   //! a SelectDeduct (as <sel>).
   //! Returns True if Done, False if <sel> is neither a
   //! SelectExtract nor a SelectDeduct, or not in the WorkSession
   Standard_EXPORT bool SetInputSelection(const occ::handle<IFSelect_Selection>& sel,
                                          const occ::handle<IFSelect_Selection>& input);
 
   //! Sets an Input Selection, Main if <formain> is True, Second else
   //! (as <sc>) to a SelectControl (as <sel>). Returns True if Done,
   //! False if <sel> is not a SelectControl, or <sc> or <sel> is not
   //! in the WorkSession
   Standard_EXPORT bool SetControl(const occ::handle<IFSelect_Selection>& sel,
                                   const occ::handle<IFSelect_Selection>& sc,
                                   const bool                             formain = true);
 
   //! Adds an input selection to a SelectCombine (Union or Inters.).
   //! Returns new count of inputs for this SelectCombine if Done or
   //! 0 if <sel> is not kind of SelectCombine, or if <seladd> or
   //! <sel> is not in the WorkSession
   //! By default, adding is done at the end of the list
   //! Else, it is an insertion to rank <atnum> (useful for Un-ReDo)
   Standard_EXPORT int CombineAdd(const occ::handle<IFSelect_Selection>& selcomb,
                                  const occ::handle<IFSelect_Selection>& seladd,
                                  const int                              atnum = 0);
 
   //! Removes an input selection from a SelectCombine (Union or
   //! Intersection). Returns True if done, False if <selcomb> is not
   //! kind of SelectCombine or <selrem> is not source of <selcomb>
   Standard_EXPORT bool CombineRemove(const occ::handle<IFSelect_Selection>& selcomb,
                                      const occ::handle<IFSelect_Selection>& selrem);
 
   //! Creates a new Selection, of type SelectPointed, its content
   //! starts with <list>. A name must be given (can be empty)
   Standard_EXPORT occ::handle<IFSelect_Selection> NewSelectPointed(
     const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& list,
     const char* const                                                          name);
 
   //! Changes the content of a Selection of type SelectPointed
   //! According <mode> : 0 set <list> as new content (clear former)
   //! 1  : adds <list> to actual content
   //! -1  : removes <list> from actual content
   //! Returns True if done, False if <sel> is not a SelectPointed
   Standard_EXPORT bool SetSelectPointed(
     const occ::handle<IFSelect_Selection>&                                     sel,
     const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& list,
     const int                                                                  mode) const;
 
   //! Returns a Selection from a Name :
   //! - the name of a Selection : this Selection
   //! - the name of a Signature + criteria between (..) : a new
   //! Selection from this Signature
   //! - an entity or a list of entities : a new SelectPointed
   //! Else, returns a Null Handle
   Standard_EXPORT occ::handle<IFSelect_Selection> GiveSelection(const char* const selname) const;
 
   //! Determines a list of entities from an object :
   //! <obj> already HSequenceOfTransient : returned itself
   //! <obj> Selection : its Result of Evaluation is returned
   //! <obj> an entity of the Model : a HSequence which contains it
   //! else, an empty HSequence
   //! <obj> the Model it self : ALL its content (not only the roots)
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> GiveList(
     const occ::handle<Standard_Transient>& obj) const;
 
   //! Computes a List of entities from two alphanums,
   //! first and second, as follows :
   //! if <first> is a Number or Label of an entity : this entity
   //! if <first> is a list of Numbers/Labels : the list of entities
   //! if <first> is the name of a Selection in <WS>, and <second>
   //! not defined, the standard result of this Selection
   //! else, let's consider "first second" : this whole phrase is
   //! split by blanks, as follows (RECURSIVE CALL) :
   //! - the leftest term is the final selection
   //! - the other terms define the result of the selection
   //! - and so on (the "leftest minus one" is a selection, of which
   //! the input is given by the remaining ...)
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> GiveList(
     const char* const first,
     const char* const second = "") const;
 
   //! Computes a List of entities from the model as follows
   //! <first> being a Selection or a combination of Selections,
   //! <ent> being an entity or a list
   //! of entities (as a HSequenceOfTransient) :
   //! the standard result of this selection applied to this list
   //! if <ent> is Null, the standard definition of the selection is
   //! used (which contains a default input selection)
   //! if <selname> is erroneous, a null handle is returned
   //!
   //! REMARK : selname is processed as <first second> of preceding
   //! GiveList
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>
     GiveListFromList(const char* const selname, const occ::handle<Standard_Transient>& ent) const;
 
   //! Combines two lists and returns the result, according to mode :
   //! <mode> < 0 : entities in <l1> AND NOT in <l2>
   //! <mode> = 0 : entities in <l1> AND in <l2>
   //! <mode> > 0 : entities in <l1> OR  in <l2>
   Standard_EXPORT occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>
     GiveListCombined(const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& l1,
                      const occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>>& l2,
                      const int mode) const;
 
   //! Loads data from a check iterator to query status on it
   Standard_EXPORT void QueryCheckList(const Interface_CheckIterator& chl);
 
   //! Determines check status for an entity regarding last call to
   //! QueryCheckList :
   //! -1 : <ent> unknown in the model, ignored
   //! 0 : no check at all, immediate or inherited thru Graph
   //! 1 : immediate warning (no fail), no inherited check
   //! 2 : immediate fail, no inherited check
   //! +10 : idem but some inherited warning (no fail)
   //! +20 : idem but some inherited fail
   Standard_EXPORT int QueryCheckStatus(const occ::handle<Standard_Transient>& ent) const;
 
   //! Determines if <entdad> is parent of <entson> (in the graph),
   //! returns : -1 if no; 0 if <entdad> = <entson>
   //! 1 if immediate parent, > 1 if parent, gives count of steps
   Standard_EXPORT int QueryParent(const occ::handle<Standard_Transient>& entdad,
                                   const occ::handle<Standard_Transient>& entson) const;
 
   //! Sets a list of Parameters, i.e. TypedValue, to be handled
   //! through an Editor
   //! The two lists are parallel, if <params> is longer than <uses>,
   //! surnumeral parameters are for general use
   //!
   //! EditForms are created to handle these parameters (list, edit)
   //! on the basis of a ParamEditor xst-params-edit
   //!
   //! A use number dispatches the parameter to a given EditForm
   //! EditForms are defined as follows
   //! Name                Use   Means
   //! xst-params          all   All Parameters (complete list)
   //! xst-params-general  1     Generals
   //! xst-params-load     2     LoadFile (no Transfer)
   //! xst-params-send     3     SendFile (Write, no Transfer)
   //! xst-params-split    4     Split
   //! xst-param-read      5     Transfer on Reading
   //! xst-param-write     6     Transfer on Writing
   Standard_EXPORT void SetParams(
     const NCollection_DynamicArray<occ::handle<Standard_Transient>>& params,
     const NCollection_DynamicArray<int>&                             uselist);
 
   //! Traces the Statics attached to a given use number
   //! If <use> is given positive (normal), the trace is embedded
   //! with a header and a trailer
   //! If <use> is negative, just values are printed
   //! (this allows to make compositions)
   //! Remark : use number  5 commands use -2 to be traced
   //! Remark : use numbers 4 and 6 command use -3 to be traced
   Standard_EXPORT void TraceStatics(const int use, const int mode = 0) const;
 
   //! Dumps contents of the ShareOut (on "cout")
   Standard_EXPORT void DumpShare() const;
 
   //! Lists the Labels of all Items of the WorkSession
   //! If <label> is defined, lists labels which contain it
   Standard_EXPORT void ListItems(const char* const label = "") const;
 
   //! Lists the Modifiers of the session (for each one, displays
   //! its Label). Listing is done following Ranks (Modifiers are
   //! invoked following their ranks)
   //! Model Modifiers if <formodel> is True, File Modifiers else
   Standard_EXPORT void ListFinalModifiers(const bool formodel) const;
 
   //! Lists a Selection and its Sources (see SelectionIterator),
   //! given its rank in the list
   Standard_EXPORT void DumpSelection(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Lists the content of the Input Model (if there is one)
   //! According level : 0 -> gives only count of Entities and Roots
   //! 1 -> Lists also Roots; 2 -> Lists all Entities (by TraceType)
   //! 3 -> Performs a call to CheckList (Fails) and lists the result
   //! 4 -> as 3 but all CheckList (Fails + Warnings)
   //! 5,6,7  : as 3 but resp. Count,List,Labels by Fail
   //! 8,9,10 : as 4 but resp. Count,List,Labels by message
   Standard_EXPORT void DumpModel(const int level, Standard_OStream& S);
 
   //! Dumps the current Model (as inherited DumpModel), on currently
   //! defined Default Trace File (default is standard output)
   Standard_EXPORT void TraceDumpModel(const int mode);
 
   //! Dumps a starting entity according to the current norm.
   //! To do this, it calls DumpEntity from WorkLibrary.
   //! <level> is to be interpreted for each norm : see specific
   //! classes of WorkLibrary for it. Generally, 0 if for very basic
   //! (only type ...), greater values give more and more details.
   Standard_EXPORT void DumpEntity(const occ::handle<Standard_Transient>& ent,
                                   const int                              level,
                                   Standard_OStream&                      S) const;
 
   //! Prints main information about an entity : its number, type,
   //! validity (and checks if any), category, shareds and sharings..
   //! mutable because it can recompute checks as necessary
   Standard_EXPORT void PrintEntityStatus(const occ::handle<Standard_Transient>& ent,
                                          Standard_OStream&                      S);
 
   //! Dumps an entity from the current Model as inherited DumpEntity
   //! on currently defined Default Trace File
   //! (<level> interpreted according to the Norm, see WorkLibrary)
   Standard_EXPORT void TraceDumpEntity(const occ::handle<Standard_Transient>& ent,
                                        const int                              level) const;
 
   //! Prints a CheckIterator to the current Trace File, controlled
   //! with the current Model
   //! complete or fails only, according to <failsonly>
   //! <mode> defines the mode of printing
   //! 0 : sequential, according entities; else with a CheckCounter
   //! 1 : according messages, count of entities
   //! 2 : id but with list of entities, designated by their numbers
   //! 3 : as 2 but with labels of entities
   Standard_EXPORT void PrintCheckList(Standard_OStream&              S,
                                       const Interface_CheckIterator& checklist,
                                       const bool                     failsonly,
                                       const IFSelect_PrintCount      mode) const;
 
   //! Prints a SignatureList to the current Trace File, controlled
   //! with the current Model
   //! <mode> defines the mode of printing (see SignatureList)
   Standard_EXPORT void PrintSignatureList(Standard_OStream&                          S,
                                           const occ::handle<IFSelect_SignatureList>& signlist,
                                           const IFSelect_PrintCount                  mode) const;
 
   //! Displays the list of Entities selected by a Selection (i.e.
   //! the result of EvalSelection).
   Standard_EXPORT void EvaluateSelection(const occ::handle<IFSelect_Selection>& sel) const;
 
   //! Displays the result of applying a Dispatch on the input Model
   //! (also shows Remainder if there is)
   //! <mode> = 0 (default), displays nothing else
   //! <mode> = 1 : displays also duplicated entities (because of
   //! this dispatch)
   //! <mode> = 2 : displays the entities of the starting Model
   //! which are not taken by this dispatch (forgotten entities)
   //! <mode> = 3 : displays both duplicated and forgotten entities
   //! Remark : EvaluateComplete displays these data evaluated for
   //! for all the dispatches, if there are several
   Standard_EXPORT void EvaluateDispatch(const occ::handle<IFSelect_Dispatch>& disp,
                                         const int                             mode = 0) const;
 
   //! Displays the effect of applying the ShareOut on the input
   //! Model.
   //! <mode> = 0 (default) : displays only roots for each packet,
   //! <mode> = 1 : displays all entities for each packet, plus
   //! duplicated entities
   //! <mode> = 2 : same as <mode> = 1, plus displays forgotten
   //! entities (which are in no packet at all)
   Standard_EXPORT void EvaluateComplete(const int mode = 0) const;
 
   //! Internal method which displays an EntityIterator
   //! <mode> 0 gives short display (only entity numbers)
   //! 1 gives a more complete trace (1 line per Entity)
   //! (can be used each time a trace has to be output from a list)
   //! 2 gives a form suitable for givelist : (n1,n2,n3...)
   Standard_EXPORT void ListEntities(const Interface_EntityIterator& iter,
                                     const int                       mode,
                                     Standard_OStream&               S) const;
 
   DEFINE_STANDARD_RTTIEXT(IFSelect_WorkSession, Standard_Transient)
 
 protected:
   occ::handle<Interface_HGraph> thegraph;
   Interface_CheckIterator       thecheckrun;
   NCollection_IndexedDataMap<occ::handle<Standard_Transient>, occ::handle<Standard_Transient>>
                                                                                 theitems;
   NCollection_DataMap<TCollection_AsciiString, occ::handle<Standard_Transient>> thenames;
 
 private:
   bool                                  theerrhand;
   occ::handle<IFSelect_ShareOut>        theshareout;
   occ::handle<IFSelect_WorkLibrary>     thelibrary;
   occ::handle<Interface_Protocol>       theprotocol;
   occ::handle<Interface_InterfaceModel> myModel;
   TCollection_AsciiString               theloaded;
   occ::handle<Interface_GTool>          thegtool;
   bool                                  thecheckdone;
   Interface_CheckIterator               thechecklist;
   TCollection_AsciiString               thecheckana;
   occ::handle<IFSelect_ModelCopier>     thecopier;
   occ::handle<Interface_InterfaceModel> theoldel;
   bool                                  themodelstat;
 };
 
 #endif // _IFSelect_WorkSession_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team