C++ CubitString类代码示例

CubitSimpleAttrib::CubitSimpleAttrib(const CubitString new_character_type,
                                     const CubitString new_string_data,
                                     const CubitString new_more_string_data,
                                     const int* new_integer_data,
                                     const double* new_double_data)
{
  assert(new_character_type.length() > 0);

  stringDataList.push_back(new_character_type);

  if (new_string_data.length()) {
    stringDataList.push_back(new_string_data);
  }
  
  if (new_more_string_data.length()) {
    stringDataList.push_back(new_more_string_data);
  }
  
  if(new_double_data)
    doubleDataList.push_back( *new_double_data );
  if(new_integer_data)
    intDataList.push_back( *new_integer_data );

  return;
}

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
}

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 '#';
  }
}

// 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 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);
  }
}

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;
}

// 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;
}

CubitStatus RefEntityName::clean(CubitString &raw_name)
{
  if (raw_name == "")
    return CUBIT_FAILURE;

    // A valid name consists of alphanumeric characters plus '.', '_', '-', or '@'
  CubitStatus found_invalid_character = CUBIT_FAILURE;

  // Initial character must be alphabetic or "_".
  char c = raw_name.get_at(0);
  if (!is_valid_first_char(c)) {
    if (is_valid_first_char(get_character("replace")))
      raw_name.put_at(0, get_character("replace"));
    else
      raw_name.put_at(0, '_');
    found_invalid_character = CUBIT_SUCCESS;
  }
  
  for (unsigned int i = 1; i < raw_name.length(); i++) {
    c = raw_name.get_at(i);
    if (!is_valid_char(c)) {
      found_invalid_character = CUBIT_SUCCESS;
      raw_name.put_at(i, get_character("replace"));
    }
  }
  return found_invalid_character;
}

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;
}

void main() {
CubitString a = "Test ";
CubitString b = "String Class";
CubitString blank(' ');

CubitString c = a + b;
c+= b;
CubitString e = c;
CubitString f = c;
CubitString g = c;
g.put_at(1, 'Z');
cout << "G = " << g << endl;
cout << "C = " << c << endl;

c.put_at(1, 'X');
CubitString d = b;
d.put_at(1, 'Y');
}

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

CubitStatus RefEntityName::generate_unique_name(CubitString &name)
{
  // The method used to generate a unique name is to append
  // 'suffixCharacter' and
  // a letter from A-Z, a-z, or 0-9 to the end of name.
  // If none of these produce a unique name, CUBIT_FALSE is returned.

  CubitString alphabet =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  CubitString suffix("  ");
  suffix.put_at(0, suffixCharacter);
  
  CubitString internal = name;

  // See if there is an suffixCharacter sign in name already. If so, is it
  // the second to the last character in the string.
  if (name.length() < 2 ||
      name.get_at(name.length()-2) != suffixCharacter) {
    // Name does not contain suffixCharacter at correct location, add one on.
    internal += suffix;
  }
  
  CubitStatus found_unique = CUBIT_FAILURE;
  int continue_trying = CUBIT_TRUE;

  while (!found_unique && continue_trying) {
	 
    continue_trying = CUBIT_FALSE;
    int name_length = internal.length();
    unsigned int number_tested = 0;
    for (unsigned int i=0; i < alphabet.length(); i++) {
      internal.put_at(name_length-1, (char)alphabet.get_at(i));
      if (!nameEntityList.move_to(internal)) {
	found_unique = CUBIT_SUCCESS;
	break;
      }
      number_tested++;
    }

    if (number_tested == alphabet.length()) {
      // All suffixes used. Add another suffixCharacter and try again
      // Name will look like '[email protected]@1' or '[email protected]@@1'...
      // Find LAST suffixCharacter in name
      int ch;
      for (ch = (int)(internal.length())-1; ch >= 0; ch--) {
	if (internal.get_at(ch) == suffixCharacter) {
	  break;
	}
      }
      if (internal.get_at(ch) == suffixCharacter) {
	// Add another suffixCharacter at ch+1
	// Assured that position ch+1 exists or we wouldn't be here
	internal.put_at(ch+1, suffixCharacter);
	if (ch+2 < (int)internal.length())
	  internal.put_at(ch+2, ' ');
	else
	  internal += " ";
	continue_trying = CUBIT_TRUE;
      }
    }
  }
  
  if (found_unique)
    name = internal;

  return found_unique;
}

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