#
# Copyright and User License
# ~~~~~~~~~~~~~~~~~~~~~~~~~~
# Copyright Vasilis.Vlachoudis@cern.ch for the
# European Organization for Nuclear Research (CERN)
#
# Please consult the flair documentation for the license
#
# DISCLAIMER
# ~~~~~~~~~~
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY, OF
# SATISFACTORY QUALITY, AND FITNESS FOR A PARTICULAR PURPOSE
# OR USE ARE DISCLAIMED. THE COPYRIGHT HOLDERS AND THE
# AUTHORS MAKE NO REPRESENTATION THAT THE SOFTWARE AND
# MODIFICATIONS THEREOF, WILL NOT INFRINGE ANY PATENT,
# COPYRIGHT, TRADE SECRET OR OTHER PROPRIETARY RIGHT.
#
# LIMITATION OF LIABILITY
# ~~~~~~~~~~~~~~~~~~~~~~~
# THE COPYRIGHT HOLDERS AND THE AUTHORS SHALL HAVE NO
# LIABILITY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
# CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES OF ANY
# CHARACTER INCLUDING, WITHOUT LIMITATION, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA OR PROFITS,
# OR BUSINESS INTERRUPTION, HOWEVER CAUSED AND ON ANY THEORY
# OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT
# LIABILITY OR OTHERWISE, ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
#
# Author:	Vasilis.Vlachoudis@cern.ch
# Date:	14-May-2004

__author__ = "Vasilis Vlachoudis"
__email__  = "Vasilis.Vlachoudis@cern.ch"

import string

_letters_digits = string.ascii_letters + string.digits
_letters_digits_symbol = _letters_digits + "_."

# abbrev
def abbrev(information, info, l=0):
	"""
	return true if the info is an abbreviation of information
	with minimum length l
	"""
	if l>0:
		length = l
	else:
		length = len(info)

	cond1 = (len(information) >= len(info))
	cond2 = (len(info) >= length)
	cond3 = (information[:len(info)] == info)
	return cond1 and cond2 and cond3

# center
def center(s, l, pad=' '):
	if l<=0: return ""

	i = l - len(s);
	if i==0:
		return s
	elif i < 0:
		i = -i
		a = i // 2
		return s[a:a+l]
	else:
		a = i // 2
		return "%s%s%s"%(pad*a, s, pad*(i-a))

# datatype
def datatype(str, check="N"):
	"""rexx datatype function"""

	try:
		if len(str)==0:
			return check=="X" or check=="B"
	except:
		return check=="X" or check=="B"

	if check=="N":
		return _isnum(str)

	if check=="A":
		return verify(str, _letters_digits)==-1
	elif check=="L":
		return verify(str, string.ascii_lowercase)==-1
	elif check=="M":
		return verify(str, string.ascii_letters)==-1
	elif check=="U":
		return verify(str, string.ascii_uppercase)==-1
	elif check=="O":
		return verify(str, string.octdigits)==-1
	elif check=="X":
		return verify(str, string.hexdigits)==-1
	elif check=="S":
		return (str[0] in string.ascii_letters) and \
			(verify(str[1:], _letters_digits_symbol)==-1)
	else:
		return _isnum(str)

# insert
def insert(new, target, n, pad=" "):
	"""
	insert new string to target as position n padded with pad characters
	"""
	if n==0:
		return new+target
	elif n>len(target):
		return target + pad*(n-len(target)) + new

	return target[0:n] + new + target[n:]

# left
def left(str, length, pad=" "):
	"""return left of string str of length padded with pad chars"""
	if length<len(str):
		return str[0:length]
	else:
		return str + (pad*(length-len(str)))

# translate
def translate(str, tableo=None, tablei=None, pad=" "):
	"""translate string"""
	# If neither input nor output tables, uppercase.
	if tableo==None and tablei==None:
		return str.upper()

	if tableo==None:
		tableo = xrange(0,255)

	if tablei==None:
		tablei = xrange(0,255)

	# The input table defaults to all characters.
	dl = len(tablei)-len(tableo)
	if dl>0:
		tableo += pad*dl
	else:
		tablei += pad*(-dl)

	tbl = string.maketrans(tablei,tableo)
	return str.translate(tbl)

# reverse
def reverse(str):
	"""reverse string"""
	return str[::-1]

# verify
def verify(str,ref,match=0,start=0):
	"""
	return the index of the first character in string that
	is not also in reference. if "Match" is given, then return
	the result index of the first character in string that is in reference
	"""

	if start<0: start = 0
	if start>=len(str): return -1

	for i in range(start,len(str)):
		found = ref.find(str[i])==-1
		if found ^ match:
			return i
	return -1

# xrange
def xrange(start,stop):
	return string.join([chr(x) for x in range(start, stop+1)],"")

# isnum - return true if string is number
def _isnum(str):
	str = str.strip()

	# accept one sign
	i = 0
	l = len(str)

	if l==0: return False

	if str[i]=='-' or str[i]=='+': i += 1

	# skip spaces after sign
	while i<l and str[i].isspace(): i += 1

	# accept many digits
	if i<l and '0'<=str[i]<='9':
		i += 1
		F  = 1
		while i<l and '0'<=str[i]<='9': i += 1
	else:
		F = 0

	# accept one dot
	if i<l and str[i]=='.':
		i+=1

		# accept many digits
		if i<l and '0'<=str[i]<='9':
			while i<l and '0'<=str[i]<='9': i += 1
		else:
			if not F: return False
	else:
		if not F: return False

	# accept one e/E/d/D
	if i<l and (str[i]=='e' or str[i]=='E' or str[i]=='d' or str[i]=='D'):
		i+=1
		# accept one sign
		if i<l and (str[i]=='-' or str[i]=='+'): i += 1

		# accept many digits
		if i<l and '0'<=str[i]<='9':
			while i<l and '0'<=str[i]<='9': i += 1
		else:
			return False

	if i != l: return False

	return True

if __name__=="__main__":
	from log import say

	say("abbrev")
	assert     abbrev('information','info',4)
	assert     abbrev('information','',0)
	assert not abbrev('information','Info',4)
	assert not abbrev('information','info',5)
	assert not abbrev('information','info ')
	assert     abbrev('information','info',3)
	assert not abbrev('info','information',3)
	assert not abbrev('info','info',5)

	say("center")
	assert center('****',0,'-')      == ''
	assert center('****',8,'-')      == '--****--'
	assert center('****',7,'-')      == '-****--'
	assert center('*****',8,'-')     == '-*****--'
	assert center('*****',7,'-')     == '-*****-'
	assert center('12345678',4,'-')  == '3456'
	assert center('12345678',5,'-')  == '23456'
	assert center('1234567',4,'-')   == '2345'
	assert center('1234567',5,'-')   == '23456'

	say("datatype")
	assert not datatype("")
	assert not datatype("foobar")
	assert not datatype("foo bar")
	assert not datatype("123.456.789")
	assert     datatype("123.456")
	assert not datatype("DeadBeef")
	assert not datatype("Dead Beef")
	assert not datatype("1234ABCD")
	assert     datatype("01001101")
	assert not datatype("0110 1101")
	assert not datatype("0110 101")
	assert     datatype("1324.1234")
	assert     datatype("123")
	assert     datatype("12.3")
	assert     datatype('123.123')
	assert     datatype('123.123E3')
	assert     datatype('123.0000003')
	assert     datatype('123.0000004')
	assert     datatype('123.0000005')
	assert     datatype('123.0000006')
	assert     datatype(' 23')
	assert     datatype(' 23 ')
	assert     datatype('23 ')
	assert     datatype('123.00')
	assert     datatype('123000E-2')
	assert     datatype('123000E+2')
	assert not datatype("A B C")
	assert not datatype("123ABC")
	assert not datatype("123AHC")
	assert     datatype('0.000E-2')
	assert     datatype('0.000E-1')
	assert     datatype('0.000E0')
	assert     datatype('0.000E1')
	assert     datatype('0.000E2')
	assert     datatype('0.000E3')
	assert     datatype('0.000E4')
	assert     datatype('0.000E5')
	assert     datatype('0.000E6')
	assert     datatype('0E-1')
	assert     datatype('0E0')
	assert     datatype('0E1')
	assert     datatype('0E2')
	assert not datatype('+.')
	assert not datatype('++0')

	say("insert")
	assert insert("abc","def",2) == "deabcf"
	assert insert("abc","def",3) == "defabc"
	assert insert("abc","def",5) == "def  abc"
	assert insert("abc","def",5,'*') == "def**abc"

	say("translate")
#	assert translate("Foo Bar"), "FOO BAR"
	assert translate("Foo Bar","","") == "Foo Bar"
#	assert translate("Foo Bar","") == "       "
#	assert translate("Foo Bar",None,None,'*') == "*******"
	assert translate("Foo Bar",xrange(1,255)) == "Gpp!Cbs"
	assert translate("","klasjdf","woieruw") == ""
	assert translate("foobar","abcdef","fedcba") == "aooefr"

	say("verify")
	assert verify('foobar', 'barfo', 0, 0)==-1
	assert verify('foobar', 'barfo', 1, 0)==0
	assert verify('', 'barfo')==-1
	assert verify('foobar', '')==0
	assert verify('foobar', 'barf', 0, 2)==2
	assert verify('foobar', 'barf', 0, 3)==-1
	assert verify('', '')==-1

	say("All Test passed")
