| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| package com.sun.star.wizards.common; |
| |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.util.DateTime; |
| import com.sun.star.beans.PropertyValue; |
| import java.util.*; |
| import java.io.File; |
| |
| import com.sun.star.lib.util.UrlToFileMapper; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| |
| /** |
| * |
| * @author bc93774 |
| */ |
| public class JavaTools |
| { |
| |
| /** Creates a new instance of JavaTools */ |
| public JavaTools() |
| { |
| } |
| |
| /* |
| public static void main(String args[]) |
| { |
| String sPath = PropertyNames.EMPTY_STRING; |
| DateTime oDateTime = null; |
| long n; |
| String ConnectStr = "uno:socket,host=localhost,port=8100;urp,negotiate=0,forcesynchronous=1;StarOffice.NamingService"; //localhost ;Lo-1.Germany.sun.com; 10.16.65.155 |
| try |
| { |
| XMultiServiceFactory xLocMSF = com.sun.star.wizards.common.Desktop.connect(ConnectStr); |
| if (xLocMSF != null) |
| { |
| System.out.println("Connected to " + ConnectStr); |
| oDateTime = getDateTime(9500000); |
| sPath = convertfromURLNotation("file:///E:/trash/Web%20Wizard.xcu"); |
| n = getMillis(oDateTime); |
| int a = 1; |
| } |
| } |
| catch (Exception exception) |
| { |
| exception.printStackTrace(System.out); |
| } |
| } |
| */ |
| public static String[] copyStringArray(String[] FirstArray) |
| { |
| if (FirstArray != null) |
| { |
| String[] SecondArray = new String[FirstArray.length]; |
| System.arraycopy(FirstArray, 0, SecondArray, 0, FirstArray.length); |
| return SecondArray; |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| public static Object[] initializeArray(Object[] olist, Object ovalue) |
| { |
| for (int i = 0; i < olist.length; i++) |
| { |
| olist[i] = ovalue; |
| } |
| return olist; |
| } |
| |
| public static Object[][] initializeMultiDimArray(Object[][] olist, Object[] ovalue) |
| { |
| for (int i = 0; i < olist.length; i++) |
| { |
| olist[i] = ovalue; |
| } |
| return olist; |
| } |
| |
| public static String[] ArrayOutOfMultiDimArray(String _sMultiDimArray[][], int _index) |
| { |
| String[] sRetArray = null; |
| if (_sMultiDimArray != null) |
| { |
| sRetArray = new String[_sMultiDimArray.length]; |
| for (int i = 0; i < _sMultiDimArray.length; i++) |
| { |
| sRetArray[i] = _sMultiDimArray[i][_index]; |
| } |
| } |
| return sRetArray; |
| } |
| |
| public static int[] initializeintArray(int FieldCount, int nValue) |
| { |
| int[] LocintArray = new int[FieldCount]; |
| for (int i = 0; i < LocintArray.length; i++) |
| { |
| LocintArray[i] = nValue; |
| } |
| return LocintArray; |
| } |
| |
| /**converts a list of Integer values included in an Integer vector to a list of int values |
| * |
| * |
| * @param _aIntegerVector |
| * @return |
| */ |
| public static int[] IntegerTointList(Vector<Integer> _aIntegerVector) |
| { |
| try |
| { |
| Integer[] nIntegerValues = new Integer[_aIntegerVector.size()]; |
| int[] nintValues = new int[_aIntegerVector.size()]; |
| _aIntegerVector.toArray(nIntegerValues); |
| for (int i = 0; i < nIntegerValues.length; i++) |
| { |
| nintValues[i] = nIntegerValues[i].intValue(); |
| } |
| return nintValues; |
| } |
| catch (RuntimeException e) |
| { |
| e.printStackTrace(System.out); |
| return null; |
| } |
| } |
| |
| /**converts a list of Boolean values included in a Boolean vector to a list of boolean values |
| * |
| * |
| * @param _aBooleanVector |
| * @return |
| */ |
| public static boolean[] BooleanTobooleanList(Vector<Boolean> _aBooleanVector) |
| { |
| try |
| { |
| Boolean[] bBooleanValues = new Boolean[_aBooleanVector.size()]; |
| boolean[] bbooleanValues = new boolean[_aBooleanVector.size()]; |
| _aBooleanVector.toArray(bBooleanValues); |
| for (int i = 0; i < bBooleanValues.length; i++) |
| { |
| bbooleanValues[i] = bBooleanValues[i].booleanValue(); |
| } |
| return bbooleanValues; |
| } |
| catch (RuntimeException e) |
| { |
| e.printStackTrace(System.out); |
| return null; |
| } |
| } |
| |
| public static String[] multiDimListToArray(String[][] multidimlist) |
| { |
| String[] retlist = new String[] |
| { |
| }; |
| retlist = new String[multidimlist.length]; |
| for (int i = 0; i < multidimlist.length; i++) |
| { |
| retlist[i] = multidimlist[i][0]; |
| } |
| return retlist; |
| } |
| |
| public static String getlongestArrayItem(String[] StringArray) |
| { |
| String sLongestItem = PropertyNames.EMPTY_STRING; |
| int FieldCount = StringArray.length; |
| int iOldLength = 0; |
| int iCurLength = 0; |
| for (int i = 0; i < FieldCount; i++) |
| { |
| iCurLength = StringArray[i].length(); |
| if (iCurLength > iOldLength) |
| { |
| iOldLength = iCurLength; |
| sLongestItem = StringArray[i]; |
| } |
| } |
| return sLongestItem; |
| } |
| |
| public static String ArraytoString(String[] LocArray) |
| { |
| StringBuilder ResultString = new StringBuilder(PropertyNames.EMPTY_STRING); |
| int iLen = LocArray.length; |
| for (int i = 0; i < iLen; i++) |
| { |
| ResultString.append(LocArray[i]); |
| if (i < iLen - 1) |
| { |
| ResultString.append(PropertyNames.SEMI_COLON); |
| } |
| } |
| return ResultString.toString(); |
| } |
| |
| /** |
| * @author bc93774 |
| * @param SearchList |
| * @param SearchString |
| * @return the index of the field that contains the string 'SearchString' or '-1' if not it is |
| * not contained within the array |
| */ |
| public static int FieldInList(String[] SearchList, String SearchString) |
| { |
| int FieldLen = SearchList.length; |
| int retvalue = -1; |
| for (int i = 0; i < FieldLen; i++) |
| { |
| if (SearchList[i].compareTo(SearchString) == 0) |
| { |
| retvalue = i; |
| break; |
| } |
| } |
| return retvalue; |
| } |
| |
| public static int FieldInList(String[] SearchList, String SearchString, int StartIndex) |
| { |
| int FieldLen = SearchList.length; |
| int retvalue = -1; |
| if (StartIndex < FieldLen) |
| { |
| for (int i = StartIndex; i < FieldLen; i++) |
| { |
| if (SearchList[i].compareTo(SearchString) == 0) |
| { |
| retvalue = i; |
| break; |
| } |
| } |
| } |
| return retvalue; |
| } |
| |
| public static int FieldInTable(String[][] SearchList, String SearchString) |
| { |
| int retvalue; |
| if (SearchList.length > 0) |
| { |
| int FieldLen = SearchList.length; |
| retvalue = -1; |
| for (int i = 0; i < FieldLen; i++) |
| { |
| if (SearchList[i][0] != null) |
| { |
| if (SearchList[i][0].compareTo(SearchString) == 0) |
| { |
| retvalue = i; |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| retvalue = -1; |
| } |
| return retvalue; |
| } |
| |
| public static int FieldInIntTable(int[][] SearchList, int SearchValue) |
| { |
| int retvalue = -1; |
| for (int i = 0; i < SearchList.length; i++) |
| { |
| if (SearchList[i][0] == SearchValue) |
| { |
| retvalue = i; |
| break; |
| } |
| } |
| return retvalue; |
| } |
| |
| public static int FieldInIntTable(int[] SearchList, int SearchValue, int _startindex) |
| { |
| int retvalue = -1; |
| for (int i = _startindex; i < SearchList.length; i++) |
| { |
| if (SearchList[i] == SearchValue) |
| { |
| retvalue = i; |
| break; |
| } |
| } |
| return retvalue; |
| } |
| |
| public static int FieldInIntTable(int[] SearchList, int SearchValue) |
| { |
| return FieldInIntTable(SearchList, SearchValue, 0); |
| } |
| |
| public static int getArraylength(Object[] MyArray) |
| { |
| int FieldCount = 0; |
| if (MyArray != null) |
| { |
| FieldCount = MyArray.length; |
| } |
| return FieldCount; |
| } |
| |
| /** |
| * @author bc93774 |
| * This function bubble sorts an array of with 2 dimensions. |
| * The default sorting order is the first dimension |
| * Only if sort2ndValue is True the second dimension is the relevant for the sorting order |
| */ |
| public static String[][] bubblesortList(String[][] SortList) |
| { |
| String DisplayDummy; |
| int SortCount = SortList[0].length; |
| int DimCount = SortList.length; |
| for (int s = 0; s < SortCount; s++) |
| { |
| for (int t = 0; t < SortCount - s - 1; t++) |
| { |
| if (SortList[0][t].compareTo(SortList[0][t + 1]) > 0) |
| { |
| for (int k = 0; k < DimCount; k++) |
| { |
| DisplayDummy = SortList[k][t]; |
| SortList[k][t] = SortList[k][t + 1]; |
| SortList[k][t + 1] = DisplayDummy; |
| } |
| } |
| } |
| } |
| return SortList; |
| } |
| |
| /** |
| * @param MainString |
| * @param Token |
| * @return |
| */ |
| public static String[] ArrayoutofString(String MainString, String Token) |
| { |
| String[] StringArray; |
| if (!MainString.equals(PropertyNames.EMPTY_STRING)) |
| { |
| Vector StringVector = new Vector(); |
| String LocString = null; |
| int iIndex; |
| do |
| { |
| iIndex = MainString.indexOf(Token); |
| if (iIndex < 0) |
| { |
| StringVector.addElement(MainString); |
| } |
| else |
| { |
| StringVector.addElement(MainString.substring(0, iIndex)); |
| MainString = MainString.substring(iIndex + 1, MainString.length()); |
| } |
| } |
| while (iIndex >= 0); |
| int FieldCount = StringVector.size(); |
| StringArray = new String[FieldCount]; |
| StringVector.copyInto(StringArray); |
| } |
| else |
| { |
| StringArray = new String[0]; |
| } |
| return StringArray; |
| } |
| |
| public static String replaceSubString(String MainString, String NewSubString, String OldSubString) |
| { |
| try |
| { |
| int NewIndex = 0; |
| int OldIndex = 0; |
| int NewSubLen = NewSubString.length(); |
| int OldSubLen = OldSubString.length(); |
| while (NewIndex != -1) |
| { |
| NewIndex = MainString.indexOf(OldSubString, OldIndex); |
| if (NewIndex != -1) |
| { |
| MainString = MainString.substring(0, NewIndex) + NewSubString + MainString.substring(NewIndex + OldSubLen); |
| OldIndex = NewIndex + NewSubLen; |
| } |
| } |
| return MainString; |
| } |
| catch (Exception exception) |
| { |
| exception.printStackTrace(System.out); |
| return null; |
| } |
| } |
| |
| public static String getFilenameOutOfPath(String sPath) |
| { |
| String[] Hierarchy = ArrayoutofString(sPath, "/"); |
| return Hierarchy[Hierarchy.length - 1]; |
| } |
| |
| public static String getFileDescription(String sPath) |
| { |
| String sFilename = getFilenameOutOfPath(sPath); |
| String[] FilenameList = ArrayoutofString(sFilename, "."); |
| StringBuilder FileDescription = new StringBuilder(PropertyNames.EMPTY_STRING); |
| for (int i = 0; i < FilenameList.length - 1; i++) |
| { |
| FileDescription.append(FilenameList[i]); |
| } |
| return FileDescription.toString(); |
| } |
| |
| public static String convertfromURLNotation(String _sURLPath) |
| { |
| String sPath = PropertyNames.EMPTY_STRING; |
| try |
| { |
| URL oJavaURL = new URL(_sURLPath); |
| File oFile = UrlToFileMapper.mapUrlToFile(oJavaURL); |
| sPath = oFile.getAbsolutePath(); |
| } |
| catch (MalformedURLException e) |
| { |
| e.printStackTrace(System.out); |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(System.out); |
| } |
| return sPath; |
| } |
| |
| public static DateTime getDateTime(long timeMillis) |
| { |
| java.util.Calendar cal = java.util.Calendar.getInstance(); |
| setTimeInMillis(cal, timeMillis); |
| DateTime dt = new DateTime(); |
| dt.Year = (short) cal.get(Calendar.YEAR); |
| dt.Day = (short) cal.get(Calendar.DAY_OF_MONTH); |
| dt.Month = (short) (cal.get(Calendar.MONTH) + 1); |
| dt.Hours = (short) cal.get(Calendar.HOUR); |
| dt.Minutes = (short) cal.get(Calendar.MINUTE); |
| dt.Seconds = (short) cal.get(Calendar.SECOND); |
| dt.HundredthSeconds = (short) cal.get(Calendar.MILLISECOND); |
| return dt; |
| } |
| |
| public static long getTimeInMillis(Calendar _calendar) |
| { |
| java.util.Date dDate = _calendar.getTime(); |
| return dDate.getTime(); |
| } |
| |
| public static void setTimeInMillis(Calendar _calendar, long _timemillis) |
| { |
| java.util.Date dDate = new java.util.Date(); |
| dDate.setTime(_timemillis); |
| _calendar.setTime(dDate); |
| } |
| |
| public static long getMillis(DateTime time) |
| { |
| java.util.Calendar cal = java.util.Calendar.getInstance(); |
| cal.set(time.Year, time.Month, time.Day, time.Hours, time.Minutes, time.Seconds); |
| return getTimeInMillis(cal); |
| } |
| |
| public static String[] removeOutdatedFields(String[] baselist, String[] _complist) |
| { |
| String[] retarray = new String[] |
| { |
| }; |
| if ((baselist != null) && (_complist != null)) |
| { |
| Vector retvector = new Vector(); |
| // String[] orderedcomplist = new String[_complist.length]; |
| // System.arraycopy(_complist, 0, orderedcomplist, 0, _complist.length); |
| for (int i = 0; i < baselist.length; i++) |
| // if (Arrays.binarySearch(orderedcomplist, baselist[i]) != -1) |
| { |
| if (FieldInList(_complist, baselist[i]) > -1) |
| { |
| retvector.add(baselist[i]); |
| // else |
| // here you could call the method of a defined interface to notify the calling method |
| // } |
| } |
| } |
| retarray = new String[retvector.size()]; |
| retvector.toArray(retarray); |
| } |
| return (retarray); |
| } |
| |
| public static String[][] removeOutdatedFields(String[][] baselist, String[] _complist, int _compindex) |
| { |
| String[][] retarray = new String[][] {}; |
| if ((baselist != null) && (_complist != null)) |
| { |
| if (baselist.length > 0) |
| { |
| Vector retvector = new Vector(); |
| for (int i = 0; i < baselist.length; i++) |
| { |
| String sValue = baselist[i][_compindex]; |
| if (FieldInList(_complist, sValue) != -1) |
| { |
| retvector.add(baselist[i]); |
| // else |
| // here you could call the method of a defined interface to notify the calling method |
| } |
| } |
| retarray = new String[retvector.size()][2]; |
| retvector.toArray(retarray); |
| } |
| } |
| return (retarray); |
| } |
| |
| public static String[][] removeOutdatedFields(String[][] baselist, String[] _complist) |
| { |
| return removeOutdatedFields(baselist, _complist, 0); |
| } |
| |
| public static PropertyValue[][] removeOutdatedFields(PropertyValue[][] baselist, String[] _complist) |
| { |
| if ((baselist != null) && (_complist != null)) |
| { |
| ArrayList<PropertyValue[]> firstdimvector = new ArrayList<PropertyValue[]>(); |
| for (int n = 0; n < baselist.length; n++) |
| { |
| ArrayList<PropertyValue> secdimvector = new ArrayList<PropertyValue>(); |
| for (int m = 0; m < baselist[n].length; m++) |
| { |
| if (FieldInList(_complist, baselist[n][m].Name) > -1) |
| { |
| secdimvector.add(baselist[n][m]); |
| } |
| } |
| if (!secdimvector.isEmpty()) |
| { |
| PropertyValue[] internalArray = new PropertyValue[secdimvector.size()]; |
| secdimvector.toArray(internalArray); |
| firstdimvector.add(internalArray); |
| } |
| } |
| PropertyValue[][] retarray = new PropertyValue[firstdimvector.size()][]; |
| return firstdimvector.toArray(retarray); |
| } |
| return new PropertyValue[][] |
| { |
| }; |
| } |
| |
| /** |
| * searches a multidimensional array for duplicate fields. According to the following example |
| * SlaveFieldName1 ;SlaveFieldName2; SlaveFieldName3 |
| * MasterFieldName1;MasterFieldName2;MasterFieldName3 |
| * The entries SlaveFieldNameX and MasterFieldNameX are grouped together and then the created groups are compared |
| * If a group is duplicate the entry of the second group is returned. |
| * @param _scomplist |
| * @return |
| */ |
| public static int getDuplicateFieldIndex(String[][] _scomplist) |
| { |
| int retvalue = -1; |
| if (_scomplist.length > 0) |
| { |
| int fieldcount = _scomplist[0].length; |
| String[] sDescList = new String[fieldcount]; |
| for (int m = 0; m < fieldcount; m++) |
| { |
| for (int n = 0; n < _scomplist.length; n++) |
| { |
| if (n == 0) |
| { |
| sDescList[m] = ""; |
| } |
| sDescList[m] += _scomplist[n][m]; |
| } |
| } |
| return getDuplicateFieldIndex(sDescList); |
| } |
| return retvalue; |
| } |
| |
| /** |
| * not tested!!!!! |
| * @param scomplist |
| * @return |
| */ |
| public static int getDuplicateFieldIndex(String[] scomplist) |
| { |
| for (int n = 0; n < scomplist.length; n++) |
| { |
| String scurvalue = scomplist[n]; |
| for (int m = n; m < scomplist.length; m++) |
| { |
| if (m != n) |
| { |
| if (scurvalue.equals(scomplist[m])) |
| { |
| return m; |
| } |
| } |
| } |
| } |
| return -1; |
| } |
| |
| public static int getDuplicateFieldIndex(String[] _scomplist, String _fieldname) |
| { |
| int iduplicate = 0; |
| for (int n = 0; n < _scomplist.length; n++) |
| { |
| if (_scomplist[n].equals(_fieldname)) |
| { |
| iduplicate++; |
| if (iduplicate == 2) |
| { |
| return n; |
| } |
| } |
| } |
| return -1; |
| } |
| |
| public static boolean isEqual(PropertyValue firstPropValue, PropertyValue secPropValue) |
| { |
| if (!firstPropValue.Name.equals(secPropValue.Name)) |
| { |
| return false; |
| //TODO replace 'equals' with AnyConverter.getType(firstpropValue).equals(secPropValue) to check content and Type |
| } |
| if (!firstPropValue.Value.equals(secPropValue.Value)) |
| { |
| return false; |
| } |
| return (firstPropValue.Handle == secPropValue.Handle); |
| } |
| |
| public static int[] getDuplicateFieldIndex(PropertyValue[][] ocomplist) |
| { |
| for (int n = 0; n < ocomplist.length; n++) |
| { |
| PropertyValue[] ocurValue = ocomplist[n]; |
| for (int m = n; m < ocurValue.length; m++) |
| { |
| PropertyValue odetValue = ocurValue[m]; |
| for (int s = 0; s < ocurValue.length; s++) |
| { |
| if (s != m) |
| { |
| if (isEqual(odetValue, ocurValue[s])) |
| { |
| return new int[] |
| { |
| n, s |
| }; |
| } |
| } |
| } |
| } |
| } |
| return new int[] |
| { |
| -1, -1 |
| }; |
| } |
| |
| public static String getSuffixNumber(String _sbasestring) |
| { |
| int suffixcharcount = 0; |
| for (int i = _sbasestring.length() - 1; i >= 0; i--) |
| { |
| char b = _sbasestring.charAt(i); |
| if ((b >= '0') && (b <= '9')) |
| { |
| suffixcharcount++; |
| } |
| else |
| { |
| break; |
| } |
| } |
| int istart = _sbasestring.length() - suffixcharcount; |
| return _sbasestring.substring(istart, _sbasestring.length()); |
| } |
| |
| public static String[] removefromList(String[] _sbaselist, String[] _sdellist) |
| { |
| Vector tempbaselist = new Vector(); |
| for (int i = 0; i < _sbaselist.length; i++) |
| { |
| if (FieldInList(_sdellist, _sbaselist[i]) == -1) |
| { |
| tempbaselist.add(_sbaselist[i]); |
| } |
| } |
| String[] sretlist = new String[tempbaselist.size()]; |
| tempbaselist.toArray(sretlist); |
| return sretlist; |
| } |
| |
| /** |
| * compares two strings. If one of them is empty and the other one is null it also returns true |
| * @param sFirstString |
| * @param sSecondString |
| * @return |
| */ |
| public static boolean isSame(String sFirstString, String sSecondString) |
| { |
| boolean bissame = false; |
| if (sFirstString == null) |
| { |
| if (sSecondString != null) |
| { |
| bissame = sSecondString.equals(PropertyNames.EMPTY_STRING); |
| } |
| else |
| { |
| bissame = true; |
| } |
| } |
| else |
| { |
| if (sFirstString.equals(PropertyNames.EMPTY_STRING)) |
| { |
| bissame = (sSecondString == null); |
| } |
| else if (sSecondString != null) |
| { |
| bissame = sFirstString.equals(sSecondString); |
| } |
| } |
| return bissame; |
| } |
| } |
