/**
* Returns an InputStream for reading the contents of the given entry.
*
* @param ze the entry to get the stream for.
* @return a stream to read the entry from.
* @throws IOException if unable to create an input stream from the zipenty
* @throws ZipException if the zipentry uses an unsupported feature
*/
public java.io.InputStream getInputStream(ZipArchiveEntry ze)
//throws IOException, ZipException
{
IAC_OffsetEntry offsetEntry = entries.get(ze);
if (offsetEntry == null)
{
return(null);
}
ZipUtil.checkRequestedFeatures(ze);
long start = offsetEntry.dataOffset;
BoundedInputStream bis =
new BoundedInputStream(this, start, ze.getCompressedSize());
switch (ze.getMethod())
{
case ZipArchiveEntry.STORED:
return(bis);
case ZipArchiveEntry.DEFLATED:
bis.addDummy();
return(new java.util.zip.InflaterInputStream(bis, new java.util.zip.Inflater(true)));
default:
throw new java.util.zip.ZipException("Found unsupported compression method "
+ ze.getMethod());
}
}
public bool setOrdering <T>(T firstProvider, T secondProvider)
{
if (firstProvider == secondProvider)
{
throw new java.lang.IllegalArgumentException(Messages.getString("imageio.98"));
}
if ((firstProvider == null) || (secondProvider == null))
{
throw new java.lang.IllegalArgumentException("Provider should be != NULL");
}
ProviderNode firstNode = nodeMap.get(firstProvider);
ProviderNode secondNode = nodeMap.get(secondProvider);
// if the ordering is already set, return false
if ((firstNode == null) || (firstNode.contains(secondNode)))
{
return(false);
}
// put secondProvider into firstProvider's outgoing nodes list
firstNode.addOutEdge(secondNode);
// increase secondNode's incoming edge by 1
secondNode.addInEdge();
return(true);
}
/**
* Returns the number of occurrence of the given element in this bag
* by looking up its count in the underlying map.
*
* @param object the object to search for
* @return the number of occurrences of the object, zero if not found
*/
public virtual int getCount(Object obj)
{
MutableInteger count = (MutableInteger)map.get(obj);
if (count != null)
{
return(count.value);
}
return(0);
}
/**
* Instantiates a zip encoding.
*
* @param name The name of the zip encoding. Specify <code>null</code> for
* the platform's default encoding.
* @return A zip encoding for the given encoding name.
*/
protected internal static ZipEncoding getZipEncoding(String name)
{
// fallback encoding is good enough for utf-8.
if (isUTF8(name))
{
return(UTF8_ZIP_ENCODING);
}
if (name == null)
{
return(new FallbackZipEncoding());
}
SimpleEncodingHolder h =
(SimpleEncodingHolder)simpleEncodings.get(name);
if (h != null)
{
return(h.getEncoding());
}
try {
java.nio.charset.Charset cs = java.nio.charset.Charset.forName(name);
return(new NioZipEncoding(cs));
}
catch (java.nio.charset.UnsupportedCharsetException)
{
return(new FallbackZipEncoding(name));
}
}
public Object next()
{
if (firstNodes.empty())
{
throw new java.util.NoSuchElementException();
}
// get a node from firstNodes
ProviderNode node = firstNodes.pop();
// find all the outgoing nodes
java.util.Iterator <Object> it = node.getOutgoingNodes();
while (it.hasNext())
{
ProviderNode outNode = (ProviderNode)it.next();
// remove the incoming edge from the node.
int edges = incomingEdges.get(outNode);
edges--;
incomingEdges.put(outNode, new java.lang.Integer(edges));
// add to the firstNodes if this node's incoming edge is equal to 0
if (edges == 0)
{
firstNodes.push(outNode);
}
}
incomingEdges.remove(node);
return(node.getProvider());
}
public override bool Equals(Object o)
{
if (!(o is java.util.Map <Object, Object>))
{
return(false);
}
java.util.Map <Object, Object> m = (java.util.Map <Object, Object>)o;
java.util.Set <Object> keys = keySet();
if (!keys.equals(m.keySet()))
{
return(false);
}
java.util.Iterator <Object> it = keys.iterator();
while (it.hasNext())
{
Key key = (Key)it.next();
Object v1 = get(key);
Object v2 = m.get(key);
if (!(v1 == null?v2 == null:v1.equals(v2)))
{
return(false);
}
}
return(true);
}
/**
* Returns the <code>Element</code> with the specified ID attribute value.
*
* <p>This implementation uses an internal {@link HashMap} to get the
* element that the specified attribute value maps to.
*
* @param idValue the value of the ID
* @return the <code>Element</code> with the specified ID attribute value,
* or <code>null</code> if none.
* @throws NullPointerException if <code>idValue</code> is <code>null</code>
* @see #setIdAttributeNS
*/
public virtual org.w3c.dom.Element getElementById(String idValue)
{
if (idValue == null)
{
throw new java.lang.NullPointerException("idValue is null");
}
return(idMap.get(idValue));
}
/**
* This implementation uses an internal {@link HashMap} to get the object
* that the specified name maps to.
*
* @throws NullPointerException {@inheritDoc}
*/
public virtual Object getProperty(String name)
{
if (name == null)
{
throw new java.lang.NullPointerException("name is null");
}
return(propMap.get(name));
}
internal override android.widget.Filter.FilterResults performFiltering(java.lang.CharSequence
prefix)
{
android.widget.Filter.FilterResults results = new android.widget.Filter.FilterResults
();
if (this._enclosing.mUnfilteredData == null)
{
this._enclosing.mUnfilteredData = new java.util.ArrayList <java.util.Map <string, object
> >(this._enclosing.mData);
}
if (prefix == null || prefix.Length == 0)
{
java.util.ArrayList <java.util.Map <string, object> > list = this._enclosing.mUnfilteredData;
results.values = list;
results.count = list.size();
}
else
{
string prefixString = prefix.ToString().ToLower();
java.util.ArrayList <java.util.Map <string, object> > unfilteredValues = this._enclosing
.mUnfilteredData;
int count = unfilteredValues.size();
java.util.ArrayList <java.util.Map <string, object> > newValues = new java.util.ArrayList
<java.util.Map <string, object> >(count);
{
for (int i = 0; i < count; i++)
{
java.util.Map <string, object> h = unfilteredValues.get(i);
if (h != null)
{
int len = this._enclosing.mTo.Length;
{
for (int j = 0; j < len; j++)
{
string str = (string)h.get(this._enclosing.mFrom[j]);
string[] words = XobotOS.Runtime.Util.SplitStringRegex(str, " ");
int wordCount = words.Length;
{
for (int k = 0; k < wordCount; k++)
{
string word = words[k];
if (word.ToLower().StartsWith(prefixString))
{
newValues.add(h);
break;
}
}
}
}
}
}
}
}
results.values = newValues;
results.count = newValues.size();
}
return(results);
}
public void testTranslationDetails()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.testtranslations.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
java.util.Map translations = archetype.getTranslations();
TranslationDetails transDet = (TranslationDetails)translations.get("de");
Assert.AreEqual("test Accreditation!", transDet.getAccreditation());
Assert.AreEqual("test organisation", transDet.getAuthor().get("organisation"));
TranslationDetails transDet2 = (TranslationDetails)translations.get("es");
Assert.AreEqual(null, transDet2.getAccreditation());
Assert.AreEqual(null, transDet2.getAuthor().get("organisation"));
}
//-----------------------------------------------------------------------
/**
* Puts all the entries from the specified map into this map.
* This operation is <b>not atomic</b> and may have undesired effects.
*
* @param map the map of entries to add
*/
public void putAll(java.util.Map <Object, Object> map)
{
java.util.Iterator <Object> i = map.keySet().iterator();
while (i.hasNext())
{
Object key = i.next();
put(key, map.get(key));
}
}
/**
* This implementation uses an internal {@link HashMap} to get the prefix
* that the specified URI maps to. It returns the <code>defaultPrefix</code>
* if it maps to <code>null</code>.
*
* @throws NullPointerException {@inheritDoc}
*/
public String getNamespacePrefix(String namespaceURI,
String defaultPrefix)
{
if (namespaceURI == null)
{
throw new java.lang.NullPointerException("namespaceURI cannot be null");
}
String prefix = nsMap.get(namespaceURI);
return(prefix != null ? prefix : defaultPrefix);
}
/**
* Gets the <code>BeanInfo</code> object which contains the information of
* the properties, events and methods of the specified bean class.
*
* <p>
* The <code>Introspector</code> will cache the <code>BeanInfo</code>
* object. Subsequent calls to this method will be answered with the cached
* data.
* </p>
*
* @param beanClass
* the specified bean class.
* @return the <code>BeanInfo</code> of the bean class.
* @throws IntrospectionException
*/
public static BeanInfo getBeanInfo(java.lang.Class beanClass)
{//throws IntrospectionException {
StandardBeanInfo beanInfo = theCache.get(beanClass);
if (beanInfo == null)
{
beanInfo = getBeanInfoImplAndInit(beanClass, null, USE_ALL_BEANINFO);
theCache.put(beanClass, beanInfo);
}
return(beanInfo);
}
protected override Object readResolve()
{// throws InvalidObjectException {
TextAttribute result = attrMap.get(this.getName());
if (result != null)
{
return(result);
}
// awt.194=Unknown attribute name
throw new java.io.InvalidObjectException("Unknown attribute name"); //$NON-NLS-1$
}
bool removeProvider(Object provider,
ServiceRegistry registry, java.lang.Class category)
{
Object obj = providers.get(provider.getClass());
if ((obj == null) || (obj != provider))
{
return(false);
}
providers.remove(provider.getClass());
nodeMap.remove(provider);
if (provider is RegisterableService)
{
((RegisterableService)provider).onDeregistration(registry, category);
}
return(true);
}
/*
* Returns the value of the attribute with the specified {@code name}.
*
* @param name
* the name of the attribute.
* @return the value of the attribute, or {@code null} if no attribute
* with the given name is set.
* @throws NullPointerException
* if {@code name} is {@code null}.
*/
public String getAttribute(String name)
{
if (name == null)
{
throw new java.lang.NullPointerException();
}
if (attributes == null)
{
return(null);
}
return(attributes.get(name));
}
public static Type GetTypeForJavaClass(java.lang.Class jclass)
{
if (jclass2type.containsKey(jclass))
{
return((Type)jclass2type.get(jclass));
}
Type t = new InternalTypes.InternalType(jclass);
jclass2type.put(jclass, t);
return(t);
}
/// <summary>
/// Converts a map to Dictionary
/// </summary>
/// <typeparam name="K">the type of keys maintained by this map</typeparam>
/// <typeparam name="V">the type of mapped values</typeparam>
/// <param name="map">the map instance</param>
/// <returns>Dictionary(of k,v)</k></returns>
public static Dictionary <K, V> ToDictionary <K, V>(this java.util.Map map)
{
var dict = new Dictionary <K, V>();
var iterator = map.keySet().iterator();
while (iterator.hasNext())
{
var key = (K)iterator.next();
dict.Add(key, (V)map.get(key));
}
return(dict);
}
/**
* Create an instance of the approriate ExtraField, falls back to
* {@link UnrecognizedExtraField UnrecognizedExtraField}.
* @param headerId the header identifier
* @return an instance of the appropiate ExtraField
* @exception InstantiationException if unable to instantiate the class
* @exception IllegalAccessException if not allowed to instatiate the class
*/
public static ZipExtraField createExtraField(ZipShort headerId)
//throws InstantiationException, IllegalAccessException
{
Type c = (Type)implementations.get(headerId);
if (c != null)
{
return((ZipExtraField)Activator.CreateInstance(c));
}
UnrecognizedExtraField u = new UnrecognizedExtraField();
u.setHeaderId(headerId);
return(u);
}
/**
* Walks through all recorded entries and adds the data available
* from the local file header.
*
* <p>Also records the offsets for the data to read from the
* entries.</p>
*/
private void resolveLocalFileHeaderData(java.util.Map <ZipArchiveEntry, IAC_NameAndComment> entriesWithoutUTF8Flag)
//throws IOException
{
java.util.Enumeration <ZipArchiveEntry> e = getEntries();
while (e.hasMoreElements())
{
ZipArchiveEntry ze = e.nextElement();
IAC_OffsetEntry offsetEntry = entries.get(ze);
long offset = offsetEntry.headerOffset;
archive.seek(offset + LFH_OFFSET_FOR_FILENAME_LENGTH);
byte[] b = new byte[SHORT];
archive.readFully(b);
int fileNameLen = ZipShort.getValue(b);
archive.readFully(b);
int extraFieldLen = ZipShort.getValue(b);
int lenToSkip = fileNameLen;
while (lenToSkip > 0)
{
int skipped = archive.skipBytes(lenToSkip);
if (skipped <= 0)
{
throw new java.lang.RuntimeException("failed to skip file name in"
+ " local file header");
}
lenToSkip -= skipped;
}
byte[] localExtraData = new byte[extraFieldLen];
archive.readFully(localExtraData);
ze.setExtra(localExtraData);
/*dataOffsets.put(ze,
* new Long(offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen));
*/
offsetEntry.dataOffset = offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen;
if (entriesWithoutUTF8Flag.containsKey(ze))
{
String orig = ze.getName();
IAC_NameAndComment nc = (IAC_NameAndComment)entriesWithoutUTF8Flag.get(ze);
ZipUtil.setNameAndCommentFromExtraFields(ze, nc.name, nc.comment);
if (!orig.equals(ze.getName()))
{
nameMap.remove(orig);
nameMap.put(ze.getName(), ze);
}
}
}
}
/**
* Applies a given attribute to this string.
*
* @param attribute
* the attribute that will be applied to this string.
* @param value
* the value of the attribute that will be applied to this
* string.
* @throws IllegalArgumentException
* if the length of this attributed string is 0.
* @throws NullPointerException
* if {@code attribute} is {@code null}.
*/
public void addAttribute(AttributedCharacterIteratorNS.Attribute attribute,
System.Object value)
{
if (null == attribute)
{
throw new java.lang.NullPointerException();
}
if (text.Length == 0)
{
throw new java.lang.IllegalArgumentException();
}
java.util.List <IAC_Range> ranges = attributeMap.get(attribute);
if (ranges == null)
{
ranges = new java.util.ArrayList <IAC_Range>(1);
attributeMap.put(attribute, ranges);
}
else
{
ranges.clear();
}
ranges.add(new IAC_Range(0, text.Length, value));
}
internal bool setOrdering <T>(java.lang.Class category, T firstProvider, T secondProvider)
{
ProvidersMap providers = categories.get(category);
if (providers == null)
{
throw new java.lang.IllegalArgumentException("Unknown category:" + category);
}
return(providers.setOrdering(firstProvider, secondProvider));
}
public static Hashtable ToHashtable(java.util.Map map)
{
if (map == null)
{
return(null);
}
Hashtable table = new Hashtable();
java.util.Iterator it = map.keySet().iterator();
while (it.hasNext())
{
string key = (string)it.next();
object val = map.get(key);
table[key] = val;
}
return(table);
}
/// <summary>
/// Converts a map to a datatable
/// </summary>
/// <param name="map">the map instance</param>
/// <returns>system.data.datatable object</returns>
public static DataTable ToDataTabe(this java.util.Map map)
{
var dt = new DataTable();
dt.Columns.Add("id", typeof(string));
dt.Columns.Add("ProjectID", typeof(string));
var iterator = map.keySet().iterator();
while (iterator.hasNext())
{
DataRow r = dt.NewRow();
var o = iterator.next();
r["id"] = o;
r["ProjectID"] = map.get(o);
dt.Rows.Add(r);
}
return(dt);
}
private void aggregateGroupDescs(java.util.Map <string, java.util.List <android.content.pm.PermissionInfo
> > map, java.util.Map <string, string> retMap)
{
if (map == null)
{
return;
}
if (retMap == null)
{
return;
}
java.util.Set <string> grpNames = map.keySet();
java.util.Iterator <string> grpNamesIter = grpNames.iterator();
while (grpNamesIter.hasNext())
{
string grpDesc = null;
string grpNameKey = grpNamesIter.next();
java.util.List <android.content.pm.PermissionInfo> grpPermsList = map.get(grpNameKey
);
if (grpPermsList == null)
{
continue;
}
foreach (android.content.pm.PermissionInfo permInfo in Sharpen.IterableProxy.Create
(grpPermsList))
{
java.lang.CharSequence permDesc = permInfo.loadLabel(mPm);
grpDesc = formatPermissions(grpDesc, permDesc);
}
// Insert grpDesc into map
if (grpDesc != null)
{
if (localLOGV)
{
android.util.Log.i(TAG, "Group:" + grpNameKey + " description:" + grpDesc.ToString
());
}
retMap.put(grpNameKey, grpDesc.ToString());
}
}
}
/// <summary>
/// Utility method that displays permissions from a map containing group name and
/// list of permission descriptions.
/// </summary>
/// <remarks>
/// Utility method that displays permissions from a map containing group name and
/// list of permission descriptions.
/// </remarks>
private void displayPermissions(bool dangerous)
{
java.util.Map <string, string> permInfoMap = dangerous ? mDangerousMap : mNormalMap;
android.widget.LinearLayout permListView = dangerous ? mDangerousList : mNonDangerousList;
permListView.removeAllViews();
java.util.Set <string> permInfoStrSet = permInfoMap.keySet();
foreach (string loopPermGrpInfoStr in Sharpen.IterableProxy.Create(permInfoStrSet
))
{
java.lang.CharSequence grpLabel = getGroupLabel(loopPermGrpInfoStr);
//guaranteed that grpLabel wont be null since permissions without groups
//will belong to the default group
if (localLOGV)
{
android.util.Log.i(TAG, "Adding view group:" + grpLabel + ", desc:" + permInfoMap
.get(loopPermGrpInfoStr));
}
permListView.addView(getPermissionItemView(grpLabel, java.lang.CharSequenceProxy.Wrap
(permInfoMap.get(loopPermGrpInfoStr)), dangerous));
}
}
protected object GetStateFromClient(FacesContext facesContext, String viewId, String renderKitId)
{
//RenderKit renderKit = RenderKitFactory.getRenderKit (facesContext, renderKitId);
//ResponseStateManager responseStateManager = renderKit.getResponseStateManager ();
//responseStateManager.getTreeStructureToRestore (facesContext, viewId); //ignore result. Must call for compatibility with sun implementation.
//return responseStateManager.getComponentStateToRestore (facesContext);
java.util.Map map = facesContext.getExternalContext().getRequestParameterMap();
string s1 = (string)map.get(VIEWSTATE);
byte [] buffer = Convert.FromBase64String(s1);
java.io.ByteArrayInputStream bytearrayinputstream = new java.io.ByteArrayInputStream(vmw.common.TypeUtils.ToSByteArray(buffer));
java.io.ObjectInputStream inputStream = new java.io.ObjectInputStream(bytearrayinputstream);
//ignore tree structure
//inputStream.readObject ();
object state = inputStream.readObject();
inputStream.close();
bytearrayinputstream.close();
return(state);
}
private static IList <KeyValuePair <T, int> > GetFieldHits <T>(java.util.Map facetMap, string fieldName, Func <string, T> decode)
{
var facetAccessor = (FacetAccessible)facetMap.get(fieldName);
if (facetAccessor == null)
{
return(null);
}
var hits = new List <KeyValuePair <T, int> >();
var facets = facetAccessor.getFacets();
for (var iter = facets.iterator(); iter.hasNext();)
{
var facet = (BrowseFacet)iter.next();
var valueString = facet.getValue();
var value = decode(valueString);
var hitCount = facet.getFacetValueHitCount();
hits.Add(new KeyValuePair <T, int>(value, hitCount));
}
return(hits);
}
/**
* Starts a new process based on the current state of this process builder.
*
* @return the new {@code Process} instance.
* @throws NullPointerException
* if any of the elements of {@link #command()} is {@code null}.
* @throws IndexOutOfBoundsException
* if {@link #command()} is empty.
* @throws SecurityException
* if {@link SecurityManager#checkExec(String)} doesn't allow
* process creation.
* @throws IOException
* if an I/O error happens.
*/
public Process start()//throws IOException {
{
if (commandJ.isEmpty())
{
throw new IndexOutOfBoundsException();
}
String[] cmdArray = new String[commandJ.size()];
for (int i = 0; i < cmdArray.Length; i++)
{
if ((cmdArray[i] = commandJ.get(i)) == null)
{
throw new NullPointerException();
}
}
String[] envArray = new String[environmentJ.size()];
int i2 = 0;
/*
* foreach (Map.Entry<String, String> entry in environmentJ.entrySet()) {
* envArray[i2++] = entry.getKey() + "=" + entry.getValue(); //$NON-NLS-1$
* }
*/
java.util.Iterator <String> it = environmentJ.keySet().iterator();
while (it.hasNext())
{
String key = it.next();
String value = environmentJ.get(key);
envArray[i2++] = key + "=" + value;
}
java.lang.Process process = Runtime.getRuntime().exec(cmdArray, envArray,
directoryJ);
// TODO implement support for redirectErrorStream
return(process);
}
public virtual Object get(Object key)
{
return(map.get(key));
}