Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) OSGi Alliance (2004, 2009). All Rights Reserved.
   * 
   * Licensed 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 org.osgi.framework;
 
 import java.util.Map;

A bundle's authority to require or provide a bundle or to receive or attach fragments.

A bundle symbolic name defines a unique fully qualified name. Wildcards may be used.

 name ::= <symbolic name> | <symbolic name ending in ".*"> | *
 
Examples:
 org.osgi.example.bundle
 org.osgi.example.*
 *
 

BundlePermission has four actions: provide, require,host, and fragment. The provide action implies the require action.

Version:
$Revision: 6860 $
Since:
1.3
ThreadSafe:
 
 
 public final class BundlePermission extends BasicPermission {
 
 	private static final long	serialVersionUID	= 3257846601685873716L;

The action string provide. The provide action implies the require action.
 
 	public final static String	PROVIDE"provide";

The action string require. The require action is implied by the provide action.
 
 	public final static String	REQUIRE"require";

The action string host.
 
 	public final static String	HOST"host";

The action string fragment.
 
 	public final static String	FRAGMENT"fragment";
 
 	private final static int	ACTION_PROVIDE		= 0x00000001;
 	private final static int	ACTION_REQUIRE		= 0x00000002;
 	private final static int	ACTION_HOST			= 0x00000004;
 	private final static int	ACTION_FRAGMENT		= 0x00000008;
 	private final static int	ACTION_ALL
 	final static int			ACTION_NONE			= 0;
The actions mask.
 
	private transient int		action_mask;

The actions in canonical form.

Serial:
	private volatile String		actionsnull;

Defines the authority to provide and/or require and or specify a host fragment symbolic name within the OSGi environment.

Bundle Permissions are granted over all possible versions of a bundle. A bundle that needs to provide a bundle must have the appropriate BundlePermission for the symbolic name; a bundle that requires a bundle must have the appropriate BundlePermssion for that symbolic name; a bundle that specifies a fragment host must have the appropriate BundlePermission for that symbolic name.

Parameters:
symbolicName The bundle symbolic name.
actions provide,require, host,fragment (canonical order).
	public BundlePermission(String symbolicNameString actions) {
		this(symbolicNameparseActions(actions));
	}

Package private constructor used by BundlePermissionCollection.

Parameters:
symbolicName the bundle symbolic name
mask the action mask
	BundlePermission(String symbolicNameint mask) {
		super(symbolicName);
	}

Called by constructors and when deserialized.

Parameters:
mask
	private synchronized void setTransients(int mask) {
		if ((mask == ) || ((mask & ) != mask)) {
			throw new IllegalArgumentException("invalid action string");
		}
		 = mask;
	}

Returns the current action mask.

Used by the BundlePermissionCollection class.

Returns:
Current action mask.
	synchronized int getActionsMask() {
		return ;
	}

Parse action string into action mask.

Parameters:
actions Action string.
Returns:
action mask.
	private static int parseActions(String actions) {
		boolean seencomma = false;
		int mask = ;
		if (actions == null) {
			return mask;
		}
		char[] a = actions.toCharArray();
		int i = a.length - 1;
		if (i < 0)
			return mask;
		while (i != -1) {
			char c;
			// skip whitespace
			while ((i != -1)
					&& ((c = a[i]) == ' ' || c == '\r' || c == '\n'
							|| c == '\f' || c == '\t'))
				i--;
			// check for the known strings
			int matchlen;
			if (i >= 6 && (a[i - 6] == 'p' || a[i - 6] == 'P')
					&& (a[i - 5] == 'r' || a[i - 5] == 'R')
					&& (a[i - 4] == 'o' || a[i - 4] == 'O')
					&& (a[i - 3] == 'v' || a[i - 3] == 'V')
					&& (a[i - 2] == 'i' || a[i - 2] == 'I')
					&& (a[i - 1] == 'd' || a[i - 1] == 'D')
					&& (a[i] == 'e' || a[i] == 'E')) {
				matchlen = 7;
			}
			else
				if (i >= 6 && (a[i - 6] == 'r' || a[i - 6] == 'R')
						&& (a[i - 5] == 'e' || a[i - 5] == 'E')
						&& (a[i - 4] == 'q' || a[i - 4] == 'Q')
						&& (a[i - 3] == 'u' || a[i - 3] == 'U')
						&& (a[i - 2] == 'i' || a[i - 2] == 'I')
						&& (a[i - 1] == 'r' || a[i - 1] == 'R')
						&& (a[i] == 'e' || a[i] == 'E')) {
					matchlen = 7;
					mask |= ;
				}
				else
					if (i >= 3 && (a[i - 3] == 'h' || a[i - 3] == 'H')
							&& (a[i - 2] == 'o' || a[i - 2] == 'O')
							&& (a[i - 1] == 's' || a[i - 1] == 'S')
							&& (a[i] == 't' || a[i] == 'T')) {
						matchlen = 4;
						mask |= ;
					}
					else
						if (i >= 7 && (a[i - 7] == 'f' || a[i - 7] == 'F')
								&& (a[i - 6] == 'r' || a[i - 6] == 'R')
								&& (a[i - 5] == 'a' || a[i - 5] == 'A')
								&& (a[i - 4] == 'g' || a[i - 4] == 'G')
								&& (a[i - 3] == 'm' || a[i - 3] == 'M')
								&& (a[i - 2] == 'e' || a[i - 2] == 'E')
								&& (a[i - 1] == 'n' || a[i - 1] == 'N')
								&& (a[i] == 't' || a[i] == 'T')) {
							matchlen = 8;
							mask |= ;
						}
						else {
							// parse error
									"invalid permission: " + actions);
						}
			// make sure we didn't just match the tail of a word
			// like "ackbarfrequire". Also, skip to the comma.
			seencomma = false;
			while (i >= matchlen && !seencomma) {
				switch (a[i - matchlen]) {
					case ',' :
						seencomma = true;
						/* FALLTHROUGH */
					case ' ' :
					case '\r' :
					case '\n' :
					case '\f' :
					case '\t' :
						break;
					default :
								"invalid permission: " + actions);
				}
				i--;
			}
			// point i at the location of the comma minus one (or -1).
			i -= matchlen;
		}
		if (seencomma) {
			throw new IllegalArgumentException("invalid permission: " + actions);
		}
		return mask;
	}

Determines if the specified permission is implied by this object.

This method checks that the symbolic name of the target is implied by the symbolic name of this object. The list of BundlePermission actions must either match or allow for the list of the target object to imply the target BundlePermission action.

The permission to provide a bundle implies the permission to require the named symbolic name.

       x.y.*,"provide" -> x.y.z,"provide" is true
       *,"require" -> x.y, "require"      is true
       *,"provide" -> x.y, "require"      is true
       x.y,"provide" -> x.y.z, "provide"  is false
 

Parameters:
p The requested permission.
Returns:
true if the specified BundlePermission action is implied by this object; false otherwise.
	public boolean implies(Permission p) {
		if (!(p instanceof BundlePermission)) {
			return false;
		}
		final int effective = getActionsMask();
		final int desired = requested.getActionsMask();
		return ((effective & desired) == desired)
				&& super.implies(requested);
	}

Returns the canonical string representation of the BundlePermission actions.

Always returns present BundlePermission actions in the following order: provide, require, host, fragment.

Returns:
Canonical string representation of the BundlePermission actions.
	public String getActions() {
		String result = ;
		if (result == null) {
			StringBuffer sb = new StringBuffer();
			boolean comma = false;
				comma = true;
			}
				if (comma)
					sb.append(',');
				comma = true;
			}
				if (comma)
					sb.append(',');
				comma = true;
			}
				if (comma)
					sb.append(',');
			}
			 = result = sb.toString();
		}
		return result;
	}

Returns a new PermissionCollection object suitable for storing BundlePermission objects.

Returns:
A new PermissionCollection object.
	}

Determines the equality of two BundlePermission objects. This method checks that specified bundle has the same bundle symbolic name and BundlePermission actions as this BundlePermission object.

Parameters:
obj The object to test for equality with this BundlePermission object.
Returns:
true if obj is a BundlePermission, and has the same bundle symbolic name and actions as this BundlePermission object; false otherwise.
	public boolean equals(Object obj) {
		if (obj == this) {
			return true;
		}
		if (!(obj instanceof BundlePermission)) {
			return false;
		}
		return (getActionsMask() == bp.getActionsMask())
				&& getName().equals(bp.getName());
	}

Returns the hash code value for this object.

Returns:
A hash code value for this object.
	public int hashCode() {
		int h = 31 * 17 + getName().hashCode();
		h = 31 * h + getActions().hashCode();
		return h;
	}

WriteObject is called to save the state of the BundlePermission object to a stream. The actions are serialized, and the superclass takes care of the name.
	private synchronized void writeObject(java.io.ObjectOutputStream s)
			throws IOException {
		// Write out the actions. The superclass takes care of the name
		// call getActions to make sure actions field is initialized
		if ( == null)
	}

readObject is called to restore the state of the BundlePermission from a stream.
	private synchronized void readObject(java.io.ObjectInputStream s)
		// Read in the action, then initialize the rest
	}
Stores a set of BundlePermission permissions.

	private static final long	serialVersionUID	= 3258407326846433079L;

Table of permissions.

GuardedBy:
this
	private transient Map		permissions;

Boolean saying if "*" is in the collection.

Serial:
GuardedBy:
this
	private boolean				all_allowed;

Create an empty BundlePermissions object.
		 = new HashMap();
		 = false;
	}

Add a permission to this permission collection.

Parameters:
permission The BundlePermission object to add.
Throws:
java.lang.IllegalArgumentException If the permission is not a BundlePermission instance.
java.lang.SecurityException If this BundlePermissionCollection object has been marked read-only.
	public void add(final Permission permission) {
		if (!(permission instanceof BundlePermission)) {
			throw new IllegalArgumentException("invalid permission: "
permission);
		}
		if (isReadOnly()) {
			throw new SecurityException("attempt to add a Permission to a "
"readonly PermissionCollection");
		}
		final BundlePermission bp = (BundlePermissionpermission;
		final String name = bp.getName();
		synchronized (this) {
			BundlePermission existing = (BundlePermissionpc.get(name);
			if (existing != null) {
				final int oldMask = existing.getActionsMask();
				final int newMask = bp.getActionsMask();
				if (oldMask != newMask) {
					pc.put(namenew BundlePermission(nameoldMask
newMask));
				}
			}
			else {
				pc.put(namebp);
			}
			if (!) {
				if (name.equals("*"))
					 = true;
			}
		}
	}

Determines if the specified permissions implies the permissions expressed in permission.

Parameters:
permission The Permission object to compare with this BundlePermission object.
Returns:
true if permission is a proper subset of a permission in the set; false otherwise.
	public boolean implies(final Permission permission) {
		if (!(permission instanceof BundlePermission)) {
			return false;
		}
		BundlePermission requested = (BundlePermissionpermission;
		String requestedName = requested.getName();
		final int desired = requested.getActionsMask();
		int effective = .;
		synchronized (this) {
			/* short circuit if the "*" Permission was added */
			if () {
				bp = (BundlePermissionpc.get("*");
				if (bp != null) {
					effective |= bp.getActionsMask();
					if ((effective & desired) == desired) {
						return true;
					}
				}
			}
			bp = (BundlePermissionpc.get(requestedName);
			// strategy:
			// Check for full match first. Then work our way up the
			// name looking for matches on a.b.*
			if (bp != null) {
				// we have a direct hit!
				effective |= bp.getActionsMask();
				if ((effective & desired) == desired) {
					return true;
				}
			}
			// work our way up the tree...
			int last;
			int offset = requestedName.length() - 1;
			while ((last = requestedName.lastIndexOf("."offset)) != -1) {
				requestedName = requestedName.substring(0, last + 1) + "*";
				bp = (BundlePermissionpc.get(requestedName);
				if (bp != null) {
					effective |= bp.getActionsMask();
					if ((effective & desired) == desired) {
						return true;
					}
				}
				offset = last - 1;
			}
			// we don't have to check for "*" as it was already checked
			// at the top (all_allowed), so we just return false
			return false;
		}
	}

Returns an enumeration of all BundlePermission objects in the container.

Returns:
Enumeration of all BundlePermission objects.
	public synchronized Enumeration elements() {
		return Collections.enumeration(.values());
	}
	/* serialization logic */
	private static final ObjectStreamField[]	serialPersistentFields	= {
			new ObjectStreamField("permissions"Hashtable.class),
			new ObjectStreamField("all_allowed".)			};
	private synchronized void writeObject(ObjectOutputStream out)
			throws IOException {
		Hashtable hashtable = new Hashtable();
		pfields.put("permissions"hashtable);
		pfields.put("all_allowed");
	}
	private synchronized void readObject(java.io.ObjectInputStream in)
		Hashtable hashtable = (Hashtablegfields.get("permissions"null);
		 = new HashMap(hashtable);
		 = gfields.get("all_allowed"false);
	}
New to GrepCode? Check out our FAQ X