zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

git-svn-id: http://webrtc.googlecode.com/svn/trunk@8 4adac7df-926f-26a2-2b94-8c16560cd09d

Browse Source
This commit is contained in:
niklase@google.com
2011-05-30 11:42:35 +00:00
parent 5c61233a88
commit 47bdc463db
10 changed files with 1312 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

303
tools/refactoring/stringmanipulation.py Normal file
View File

@ -0,0 +1,303 @@
import string
# returns tuple, [success,updated_string] where the updated string has
# has one less (the first) occurance of match string
def removefirstoccurance( remove_string, match_string ):
lowercase_string = remove_string.lower()
lowercase_match_string = match_string.lower()
lowest_index = lowercase_string.find(lowercase_match_string)
if(lowest_index == -1):
return [False,remove_string]
past_match_index = lowest_index + len(lowercase_match_string)
highest_index = len(remove_string)
remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index]
return [True,remove_string]
# returns a string with all occurances of match_string removed
def removealloccurances( remove_string, match_string ):
return_value = [True, remove_string]
while(return_value[0]):
return_value = removefirstoccurance(return_value[1],match_string)
return return_value[1]
# removes an occurance of match_string only if it's first in the string
# returns tuple [succes, new_string]
def removeprefix( remove_string, match_string ):
lowercase_string = remove_string.lower()
lowercase_match_string = match_string.lower()
lowest_index = lowercase_string.find(lowercase_match_string)
if(lowest_index == -1):
return [False,remove_string]
if(lowest_index != 0):
return [False,remove_string]
past_match_index = lowest_index + len(lowercase_match_string)
highest_index = len(remove_string)
remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index]
# print lowest_index
# print past_match_index
return [True,remove_string]
# removes multiple occurances of match string as long as they are first in
# the string
def removeallprefix( remove_string, match_string ):
return_value = [True, remove_string]
while(return_value[0]):
return_value = removeprefix(return_value[1],match_string)
return return_value[1]
# returns true if extensionstring is a correct extension
def isextension( extensionstring ):
if(len(extensionstring) < 2):
return False
if(extensionstring[0] != '.'):
return False
if(extensionstring[1:len(extensionstring)-1].find('.') != -1):
return False
return True
# returns the index of start of the last occurance of match_string
def findlastoccurance( original_string, match_string ):
search_index = original_string.find(match_string)
found_index = search_index
last_index = len(original_string) - 1
while((search_index != -1) and (search_index < last_index)):
search_index = original_string[search_index+1:last_index].find(match_string)
if(search_index != -1):
found_index = search_index
return found_index
# changes extension from original_extension to new_extension
def changeextension( original_string, original_extension, new_extension):
if(not isextension(original_extension)):
return original_string
if(not isextension(new_extension)):
return original_string
index = findlastoccurance(original_string, original_extension)
if(index == -1):
return original_string
return_value = original_string[0:index] + new_extension
return return_value
# wanted to do this with str.find however didnt seem to work so do it manually
# returns the index of the first capital letter
def findfirstcapitalletter( original_string ):
for index in range(len(original_string)):
if(original_string[index].lower() != original_string[index]):
return index
return -1
# replaces capital letters with underscore and lower case letter (except very
# first
def lowercasewithunderscore( original_string ):
# ignore the first letter since there should be no underscore in front of it
if(len(original_string) < 2):
return original_string
return_value = original_string[1:len(original_string)]
index = findfirstcapitalletter(return_value)
while(index != -1):
return_value = return_value[0:index] + \
'_' + \
return_value[index].lower() + \
return_value[index+1:len(return_value)]
index = findfirstcapitalletter(return_value)
return_value = original_string[0].lower() + return_value
return return_value
# my table is a duplicate of strings
def removeduplicates( my_table ):
new_table = []
for old_string1, new_string1 in my_table:
found = 0
for old_string2, new_string2 in new_table:
if(old_string1 == old_string2):
found += 1
if(new_string1 == new_string2):
if(new_string1 == ''):
found += found
else:
found += 1
if(found == 1):
print 'missmatching set, terminating program'
print old_string1
print new_string1
print old_string2
print new_string2
quit()
if(found == 2):
break
if(found == 0):
new_table.append([old_string1,new_string1])
return new_table
def removenochange( my_table ):
new_table = []
for old_string, new_string in my_table:
if(old_string != new_string):
new_table.append([old_string,new_string])
return new_table
# order table after size of the string (can be used to replace bigger strings
# first which is useful since smaller strings can be inside the bigger string)
# E.g. GIPS is a sub string of GIPSVE if we remove GIPS first GIPSVE will never
# be removed. N is small so no need for fancy sort algorithm. Use selection sort
def ordertablesizefirst( my_table ):
for current_index in range(len(my_table)):
biggest_string = 0
biggest_string_index = -1
for search_index in range(len(my_table)):
if(search_index < current_index):
continue
length_of_string = len(my_table[search_index][0])
if(length_of_string > biggest_string):
biggest_string = length_of_string
biggest_string_index = search_index
if(biggest_string_index == -1):
print 'sorting algorithm failed, program exit'
quit()
old_value = my_table[current_index]
my_table[current_index] = my_table[biggest_string_index]
my_table[biggest_string_index] = old_value
return my_table
# returns true if string 1 or 2 is a substring of the other, assuming neither
# has whitespaces
def issubstring( string1, string2 ):
if(len(string1) == 0):
return -1
if(len(string2) == 0):
return -1
large_string = string1
small_string = string2
if(len(string1) < len(string2)):
large_string = string2
small_string = string1
for index in range(len(large_string)):
large_sub_string = large_string[index:index+len(small_string)].lower()
if(large_sub_string ==\
small_string.lower()):
return index
return -1
#not_part_of_word_table = [' ','(',')','{','}',':','\t','*','&','/','[',']','.',',','\n']
#def ispartofword( char ):
# for item in not_part_of_word_table:
# if(char == item):
# return False
# return True
# must be numerical,_ or charachter
def ispartofword( char ):
if(char.isalpha()):
return True
if(char.isalnum()):
return True
if(char == '_'):
return True
return False
# returns the index of the first letter in the word that the current_index
# is pointing to and the size of the word
def getword( line, current_index):
if(current_index < 0):
return []
line = line.rstrip()
if(len(line) <= current_index):
return []
if(line[current_index] == ' '):
return []
start_pos = current_index
while start_pos >= 0:
if(not ispartofword(line[start_pos])):
start_pos += 1
break
start_pos -= 1
if(start_pos == -1):
start_pos = 0
end_pos = current_index
while end_pos < len(line):
if(not ispartofword(line[end_pos])):
break
end_pos += 1
return [start_pos,end_pos - start_pos]
# my table is a tuple [string1,string2] complement_to_table is just a list
# of strings to compare to string1
def complement( my_table, complement_to_table ):
new_table = []
for index in range(len(my_table)):
found = False;
for compare_string in complement_to_table:
if(my_table[index][0].lower() == compare_string.lower()):
found = True
if(not found):
new_table.append(my_table[index])
return new_table
def removestringfromhead( line, remove_string):
for index in range(len(line)):
if(line[index:index+len(remove_string)] != remove_string):
return line[index:index+len(line)]
return ''
def removeccomment( line ):
comment_string = '//'
for index in range(len(line)):
if(line[index:index+len(comment_string)] == comment_string):
return line[0:index]
return line
def whitespacestoonespace( line ):
return ' '.join(line.split())
def fixabbreviations( original_string ):
previouswascapital = (original_string[0].upper() == original_string[0])
new_string = ''
for index in range(len(original_string)):
if(index == 0):
new_string += original_string[index]
continue
if(original_string[index] == '_'):
new_string += original_string[index]
previouswascapital = False
continue
if(original_string[index].isdigit()):
new_string += original_string[index]
previouswascapital = False
continue
currentiscapital = (original_string[index].upper() == original_string[index])
letter_to_add = original_string[index]
if(previouswascapital and currentiscapital):
letter_to_add = letter_to_add.lower()
if(previouswascapital and (not currentiscapital)):
old_letter = new_string[len(new_string)-1]
new_string = new_string[0:len(new_string)-1]
new_string += old_letter.upper()
previouswascapital = currentiscapital
new_string += letter_to_add
return new_string
def replaceoccurances(old_string, replace_string, replace_with_string):
if (len(replace_string) == 0):
return old_string
if (len(old_string) < len(replace_string)):
return old_string
# Simple implementation, could proably be done smarter
new_string = ''
for index in range(len(old_string)):
#print new_string
if(len(replace_string) > (len(old_string) - index)):
new_string += old_string[index:index + len(old_string)]
break
match = (len(replace_string) > 0)
for replace_index in range(len(replace_string)):
if (replace_string[replace_index] != old_string[index + replace_index]):
match = False
break
if (match):
new_string += replace_with_string
index =+ len(replace_string)
else:
new_string += old_string[index]
return new_string