C++ CubitString::c_str方法代码示例

CubitString RefEntityName::base_name(const CubitString& name)
{
  const char *pos = strchr(name.c_str(), suffixCharacter);
  if (!pos)
    return name;
  return name.substr(0, pos - name.c_str());
}

void CubitUtil::setenv(const CubitString& var, const CubitString& value)
{
#ifdef WIN32
  ::SetEnvironmentVariableW(CubitString::toUtf16(var).c_str(), CubitString::toUtf16(value).c_str());
#else
  ::setenv(var.c_str(), value.c_str(), 1);
#endif
}

// returns CUBIT_TRUE if the two names have the same base name (i.e.
// the same name before the first suffixCharacter
CubitBoolean RefEntityName::same_base_name(const CubitString &name1,
                                           const CubitString &name2)
{
  const char *pos1 = strchr(name1.c_str(), suffixCharacter);
  const char *pos2 = strchr(name2.c_str(), suffixCharacter);

    // check for replacement character in one but not the other
  int length1, length2;
  if (pos1 == NULL)
    length1 = strlen(name1.c_str());
  else
    length1 = pos1 - name1.c_str();

  if (pos2 == NULL)
    length2 = strlen(name2.c_str());
  else
    length2 = pos2 - name2.c_str();

    // if the lengths are different, the base names are also different
  if (length1 != length2)
    return CUBIT_FALSE;

  if (strncmp(name1.c_str(), name2.c_str(), length1) == 0)
    return CUBIT_TRUE;
  else
    return CUBIT_FALSE;
}

void CubitMessage::output_debug_information(CubitString &match)
{
  int count = 0;
  for (int i=1; i <= number_of_debug_flags(); i++) {
    char *tmp = CubitUtil::util_strdup((char*)(debugFlag[i].description));
    if (tmp && strlen(tmp) > 0) {
      CubitString debug_description(tmp);
      debug_description.to_lower();
      if (debug_description.find(match, 0) < debug_description.length()) {
	if (count == 0) {
	  PRINT_INFO("Debug Flag Settings "
		     "(flag number, setting, output to, description):\n");
	}
	debugFlag[i].output();
	count++;
      }
    }
    CubitUtil::util_strdup_free(tmp);
  }
  if (count == 0) {
    PRINT_WARNING("No debug descriptions contain the "
		  "substring '%s'\n", match.c_str());
  }
  PRINT_INFO("\n");
}

size_t CubitString::find(const CubitString& s, size_t pos) const
{
  assert(pos < length());
  char *p = strstr(rep->chars,s.c_str());
  if (p)
    return pos + (p - rep->chars);
  return MAX_POS;
}

char RefEntityName::get_character(const CubitString& type) const
{
  if (type.get_at(0) == 'R' || type.get_at(0) == 'r')
    return replacementCharacter;
  else if (type.get_at(0) == 'S' || type.get_at(0) == 's')
    return suffixCharacter;  
  else {
    PRINT_ERROR("Invalid character type '%s', must be "
		"'replacement' or 'suffix'\n", type.c_str());
    return '#';
  }
}

void RefEntityName::set_character(char rep, const CubitString &type)
{
  if (is_valid_char(rep)) {
    if (type.get_at(0) == 'R' || type.get_at(0) == 'r')
      replacementCharacter = rep;
    else if (type.get_at(0) == 'S' || type.get_at(0) == 's')
      suffixCharacter = rep;
    else
      PRINT_ERROR("Invalid character type '%s', must be "
		  "'replacement' or 'suffix'\n", type.c_str());
  } else {
    PRINT_ERROR("Character '%c' is not a valid entity name character\n",
		rep);
  }
}

// given a relative or absolute path, make it absolute
static std::string make_path_absolute(const std::string& p)
{
  std::string ret;
  if(!p.empty())
  {
    if ( CubitFileUtil::is_absolute(p.c_str()) )
    {
      ret = p;
    }
    else
    {
      // if any '/' character is in it, its relative to current directory
      CubitString wd;
      CubitFileUtil::get_current_working_directory(wd);
      ret = wd.c_str();
      ret += path_separator;
      ret += p;
    }
  }
  return ret;
}

CubitString CubitUtil::get_temporary_filename()
{

  CubitString ret_str;

#ifdef WIN32
  
  //get a place to put the temporary file
  CubitString temp_path = get_temp_directory();

  // make an empty temporary and return the name for it
  wchar_t temp_file_name[MAX_PATH];
  if( GetTempFileNameW(CubitString::toUtf16(temp_path.c_str()).c_str(), L"CBT", 0, temp_file_name) != 0 )
    ret_str = CubitString::toUtf8(temp_file_name); 

#else

  CubitString tmpdir = get_temp_directory();
  const char* filepattern = "CBT.XXXXXX";
    //needs to be two longer because of the "/"?
  char *temp_file_name = new char[tmpdir.length() + strlen(filepattern) + 2];
  sprintf(temp_file_name, "%s/%s", tmpdir.c_str(), filepattern);

  // make an empty file and return the name for it
  int fd = mkstemp(temp_file_name);
  if( fd != -1 )
  {
    ret_str = temp_file_name; 
    // release the open done by mkstemp,
    // temporary file still exists
    close(fd);
  }
  delete [] temp_file_name;

#endif

  return ret_str;
}

bool operator>( const CubitString& s1, const CubitString& s2 )
{ return strcmp( s1.c_str(), s2.c_str() ) > 0; }

CubitString CubitUtil::getenv(const CubitString& var)
{
  return CubitString(::getenv(var.c_str()));
}

void RefEntityName::set_replacement_setting(CubitString rep)
{
  const char* tmp = rep.c_str();
  replacementCharacter = tmp[0];
}

void RefEntityName::set_suffix_setting(CubitString rep)
{
  const char* tmp = rep.c_str();
  suffixCharacter = tmp[0];
}

CubitStatus RefEntityName::add_refentity_name(RefEntity *entity,
                                              CubitString &name,
                                              bool update_attribs,
                                              bool check_name_validity)
{
  if (name == "")
    return CUBIT_FAILURE;
  
  CubitString in_name = name;
  bool warn_name_change = false;
  
  if (check_name_validity)
  {
    if (clean(name))
    {
      // Assign the invalid name anyway, then continue on and
      // assign the modified name.
      add_refentity_name(entity, in_name, false, false);
      warn_name_change = true;
    }
  }
  
  if (nameEntityList.move_to(name))
  {
    RefEntity *old_entity = nameEntityList.get()->value();
    if (old_entity == entity)
    {
        // Tried to assign same name to entity
      if ( DEBUG_FLAG(92) ) 
      {
        PRINT_INFO("Entity name '%s' already assigned to %s %d\n",
                   name.c_str(), 
                   entity->class_name(), entity->id());
        return CUBIT_FAILURE;
      }
      return CUBIT_SUCCESS;
    }
    else
    {
        // Tried to assign existing name to another entity
      if ( DEBUG_FLAG(92) )
        PRINT_WARNING("Entity name '%s' for %s %d is already used by %s %d\n",
                      name.c_str(),
                      entity->class_name(), entity->id(),
                      old_entity->class_name(), old_entity->id());
      if (get_fix_duplicate_names())
      {
        if (generate_unique_name(name))
        {
          if (warn_name_change)
          {
            PRINT_WARNING("Entity name '%s' can't be used in commands.\n"
                 "         Additional name '%s' assigned.\n",
              in_name.c_str(), name.c_str());
          }
          if ( DEBUG_FLAG(92) )
            PRINT_WARNING("\t%s %d name changed to '%s'\n",
            entity->class_name(), entity->id(), name.c_str());
          return add_refentity_name(entity, name, update_attribs, false);
        }
      }
      return CUBIT_FAILURE;
    }
  }

  if (warn_name_change)
  {
    PRINT_WARNING("Entity name '%s' can't be used in commands.\n"
      "         Additional name '%s' assigned.\n",
      in_name.c_str(), name.c_str());
  }

  RefEntityNameMap *entity_name =
    new RefEntityNameMap(name, entity);
  nameEntityList.insert(entity_name);
  
  if (update_attribs == CUBIT_TRUE)
  {
      // now tell the entity to update its name attribute
    CubitAttrib *attrib = entity->get_cubit_attrib(CA_ENTITY_NAME);
      // force update by resetting update flag
    attrib->has_updated(CUBIT_FALSE);
    attrib->update();
  }
  
  return CUBIT_SUCCESS;
}