root/cgm/cgm_apps/TSTT/CATSTT.hpp @ 1040

//- Class:          CATSTT
//- Owner:          Greg Nielson
//- Description:    Cubit attribute for entity names.
//- Checked by:
//- Version:

#ifndef CA_TSTT_HPP
#define CA_TSTT_HPP

#include "sidlArray.h"
#include "TSTTG.hh"
#include "CubitAttrib.hpp"
#include "DLIList.hpp"
#include "CubitDefines.h"

#include <string>
#include <map>
#include <vector>

#define ARRAY_IN_DECL(a, b) \
  a *b, const int b ## _size  

#define ARRAY_INOUT_DECL(a, b) \
  a **b, int *b ## _allocated, int *b ## _size  

class RefEntity;
class RefGroup;

class CGMTagManager 
{
public:

  friend class CATSTT;
  
  CGMTagManager();
  ~CGMTagManager();
  
  struct TagInfo
  {
    int tagLength;
    std::string tagName;
    int tagType;
    char *defaultValue;
    bool isActive;
  };
  
  static CubitAttrib* CATSTT_creator(RefEntity* entity, CubitSimpleAttrib *p_csa);

  CubitStatus createTag (/*in*/ const char *tag_name,
                         /*in*/ const int tag_size,
                         /*in*/ const int tag_type,
                         /*in*/ char* default_value,
                         /*out*/ int *tag_handle);

  CubitStatus destroyTag (/*in*/ const int tag_handle,
                          /*in*/ const bool forced);

  const char *getTagName (/*in*/ const int tag_handle);

  int getTagSize (/*in*/ const int tag_handle);

  int getTagHandle (/*in*/ const char *tag_name);

  int getTagType (/*in*/ const int tag_handle);

  CubitStatus getArrData (const RefEntity**entity_handles, 
                          const int entity_handles_size,
                          /*in*/ const int tag_handle,
                          /*inout*/ ARRAY_INOUT_DECL(char, tag_value));

  CubitStatus setArrData (/*in*/ ARRAY_IN_DECL(RefEntity*, entity_handles),
                          /*in*/ const int tag_handle,
                          /*in*/ const char *tag_values,
                          const int tag_values_size);

  CubitStatus rmvArrTag (/*in*/ ARRAY_IN_DECL(RefEntity*, entity_handles),
                         /*in*/ const int tag_handle);

  CubitStatus getAllTags (/*in*/ const RefEntity* entity_handle,
                          /*inout*/ ARRAY_INOUT_DECL(int, tag_handles));

  std::vector<RefGroup*> *pc_list(RefEntity *gentity, int list_no, 
                                  const bool create_if_missing);

  void pc_list(RefEntity *gentity, std::vector<RefGroup*> *&parents,
               std::vector<RefGroup*> *&children,
               const bool create_if_missing);

  void get_pc_groups(RefGroup *this_grp, const int p_or_c, const int num_hops,
                     std::vector<RefGroup *> &group_ptrs);

private:
  int CATSTT_att_type;
  int pcTag;
  std::vector<TagInfo> tagInfo;
  std::vector<TagInfo> presetTagInfo;
  std::map<std::string, int> tagNameMap;
  static const char *CATSTT_NAME;
  static const char *CATSTT_NAME_INTERNAL;
  RefGroup *interfaceGroup;
  static CGMTagManager *staticCGMTagManager;

  bool getPresetTagData(const RefEntity *entity, const int tag_num, 
                        char *tag_value, int &tag_size);

  void setPresetTagData(RefEntity *entity, const int tag_num, 
                        const char *tag_value, const int tag_size);
  
  CATSTT *get_catstt(RefEntity *ent, 
                     const bool create_if_missing = false);

  int pc_tag(const bool create_if_missing = false);
  
  RefGroup *interface_group(const bool create_if_missing = true);
  
};

class CATSTT: public CubitAttrib
{
private:
  friend class CGMTagManager;
 
  std::map<int, void*> tagData;

  CGMTagManager *myManager;

  CATSTT(CGMTagManager *manager, RefEntity *owner);

  CATSTT(CGMTagManager *manager, RefEntity *owner, CubitSimpleAttrib *csa_ptr);
    //- create a CATSTT from a simple attribute

public:

  virtual ~CATSTT();

  //HEADER- RTTI and safe casting functions.
  virtual const type_info& entity_type_info() const
     { return typeid(CATSTT);}
  //R- The geometric modeler type
  //- This function returns the type of the geometric modeler.

  CubitStatus actuate() {return CUBIT_SUCCESS;}

  CubitStatus update();

  CubitStatus reset();

  CubitSimpleAttrib *split_owner() {return NULL;}

  void merge_owner(CubitAttrib *deletable_attrib) {}

  CubitSimpleAttrib* cubit_simple_attrib();

  int int_attrib_type() {return myManager->CATSTT_att_type;}

  void add_csa_data(CubitSimpleAttrib *csa_ptr);

  void print();

  CubitStatus get_tag_data(int tag_num, void *tag_data);
  
  CubitStatus set_tag_data(int tag_num, const void *tag_data,
       const bool can_shallow_copy = false);

  void remove_tag(int tag_num);
};

#endif