Processes {@link HierarchicalProperty} instance, representing grant or deny
element of ACL request body, to pull out permissions set represented as {@link String} array.
@param property
@return String[] - permissions set
14680
private String[] getPermissions(HierarchicalProperty property)
   {
      Set<String> permissionsToBeChanged = new HashSet<String>();

      // grant|deny element must have at least one privilege element
      // <!ELEMENT grant (privilege+)> 
      // <!ELEMENT deny (privilege+)> 
      if (property.getChildren().size() == 0)
      {
         throw new IllegalArgumentException("Malformed grant|deny element (seems that no privilige is specified)");
      }

      for (HierarchicalProperty propertyRunner : property.getChildren())
      {
         HierarchicalProperty permissionProperty;

         // obviously privilege must be single named
         // <!ELEMENT privilege ANY>
         if (ACLProperties.PRIVILEGE.equals(propertyRunner.getName()))
         {
            if (propertyRunner.getChildren().size() > 1)
            {
               throw new IllegalArgumentException(
                  "Malformed privilege name (element privilege must contain only one element)");
            }
            permissionProperty = propertyRunner.getChild(0);
         }
         else
         {
            permissionProperty = propertyRunner;
         }

         if (ACLProperties.READ.equals(permissionProperty.getName()))
         {
            permissionsToBeChanged.add(PermissionType.READ);

         }
         else if (ACLProperties.WRITE.equals(permissionProperty.getName()))
         {
            permissionsToBeChanged.add(PermissionType.ADD_NODE);
            permissionsToBeChanged.add(PermissionType.SET_PROPERTY);
            permissionsToBeChanged.add(PermissionType.REMOVE);

         }
         else if (ACLProperties.ALL.equals(permissionProperty.getName()))
         {
            permissionsToBeChanged.add(PermissionType.READ);
            permissionsToBeChanged.add(PermissionType.ADD_NODE);
            permissionsToBeChanged.add(PermissionType.SET_PROPERTY);
            permissionsToBeChanged.add(PermissionType.REMOVE);
         }
         // in case privilege with specified name is unsupported
         // or simply incorrect privilege name
         else
         {
            throw new IllegalArgumentException("Malformed privilege element (unsupported privilege name)");
         }
      }
      return permissionsToBeChanged.toArray(new String[0]);
      
   }
924592
public Object[] jcrValues( Property<?> property ) {
        @SuppressWarnings( "unchecked" )
        List<Object> values = (List<Object>)property.getValues();

        // convert CMIS values to JCR values
        switch (property.getType()) {
            case STRING:
                return asStrings(values);
            case BOOLEAN:
                return asBooleans(values);
            case DECIMAL:
                return asDecimals(values);
            case INTEGER:
                return asIntegers(values);
            case DATETIME:
                return asDateTime(values);
            case URI:
                return asURI(values);
            case ID:
                return asIDs(values);
            case HTML:
                return asHTMLs(values);
            default:
                return null;
        }
    }
830895
public JsonObject getAsObject(String property) {
		if (!super.has(property)) {
			super.set(property, new JsonValue(new JsonObject()), false);
		}
		return get(property).getAsObject();
	}
826528
private HierarchicalProperty getProperty(Node node, QName name) throws PathNotFoundException, RepositoryException
   {
      Property property = node.getProperty(WebDavNamespaceContext.createName(name));
      String propertyValue;
      if (property.getDefinition().isMultiple())
      {
         if (property.getValues().length >= 1)
         {
            propertyValue = property.getValues()[0].getString();
         }
         else
         {
            // this means that we return empty value, because according to WebDAV spec:
            // this is a property whose semantics and syntax are not enforced by the server
            // the server only records the value of a dead property;
            // the client is responsible for maintaining the consistency of the syntax and semantics of a dead property. 
            propertyValue = "";
         }
      }
      else
      {
         propertyValue = property.getString();
      }
      return new HierarchicalProperty(name, propertyValue);
   }
75321
public String[] getUserPermissionList(String userName) {
        if (!m_enabled) {
            return m_perm_list;
        }
        if (userName == null) {
            return new String[] {};
        }
        AuthUser user = getUser(userName);
        if (user == null) {
            return new String[] {};
        }
        return user.m_permissions_list;
    }
883130
public Object getAsRaw(String property) {
		if (super.has(property)) {
			return get(property).getAsRaw();
		}
		return null;
	}
676969
function getProperties( property ) {
    var properties = property[ PROPERTY_SYMBOL ];
    if ( !Array.isArray( properties ) ) return null;
    return properties;
}
1215718
@Exported(name = "property", inline = true)
    public List<UserProperty> getAllProperties() {
        if (hasPermission(Jenkins.ADMINISTER)) {
            return Collections.unmodifiableList(properties);
        }

        return Collections.emptyList();
    }
985184
public String value(String property) {

		Xpp3Dom propNode = get(property);

		if (propNode == null) {
			// not found
			return null;
		}

		return propNode.getValue();
	}
112683
public static ConfigID fromProperty(String property) {
        //TODO Perhaps there is a clever regex that could handle this
        String[] parents = property.split("//");

        ConfigID id = null;
        for (String parentString : parents) {
            id = constructId(id, parentString);
        }

        return id;
    }
888740
protected Collection<String> getPropertyValues(final Property property) {
        final ExtendedIterator<Triple> iterator = graph.find(Node.ANY,
                                                             property.asNode(),
                                                             Node.ANY);
        final Set<String> set = new HashSet<>();
        while (iterator.hasNext()) {
            final Node object = iterator.next().getObject();
            if (object.isLiteral()) {
                set.add(object.getLiteralValue().toString());
            } else if (object.isURI()) {
                set.add(object.getURI().toString());
            } else {
                set.add(object.toString());
            }
        }
        return set;
    }
641359
private static java.util.Properties getSSLPropertiesOnThread() {
        return AccessController.doPrivileged(new PrivilegedAction<java.util.Properties>() {
            @Override
            public java.util.Properties run() {
                return JSSEHelper.getInstance().getSSLPropertiesOnThread();
            }
        });
    }
727215
public function getPropertyValues($property)
    {
        $returnValue = null;
        switch ($property) {
            case GenerisRdf::PROPERTY_USER_DEFLG :
                $returnValue = array(DEFAULT_LANG);
                break;
            case GenerisRdf::PROPERTY_USER_UILG :
                $returnValue = array($this->language);
                break;
            case  GenerisRdf::PROPERTY_USER_ROLES :
                $returnValue = $this->taoRoles;
                break;
            case  GenerisRdf::PROPERTY_USER_FIRSTNAME :
                $returnValue = [$this->firstname];
                break;
            case  GenerisRdf::PROPERTY_USER_LASTNAME :
                $returnValue = [$this->lastname];
                break;
            case  OntologyRdfs::RDFS_LABEL :
                $returnValue = [$this->label];
                break;
            default:
                \common_Logger::d('Unkown property ' . $property . ' requested from ' . __CLASS__);
                $returnValue = array();
        }
        return $returnValue;
    }
163331
public static String[] jcrPermissions( String cmisPermission ) {
        switch (cmisPermission) {
            case "cmis:read" :
                return new String[] {
                    Privilege.JCR_READ,
                    Privilege.JCR_READ_ACCESS_CONTROL
                };
            case "cmis:write" : 
                return new String[] {
                    Privilege.JCR_WRITE,
                    Privilege.JCR_READ_ACCESS_CONTROL,
                    Privilege.JCR_MODIFY_ACCESS_CONTROL,
                    Privilege.JCR_NODE_TYPE_MANAGEMENT,
                    Privilege.JCR_RETENTION_MANAGEMENT,
                    Privilege.JCR_VERSION_MANAGEMENT
                };
            case "cmis:all" :
                return new String[] {Privilege.JCR_ALL};
            default :
                    return null;
        }
    }
1357390
public static List<Entry> permissionStructureFromPermissionData(Collection<PermissionData> data, Dn baseDn) {

        List<Entry> permissions = new LinkedList<Entry>();
        List<Entry> properties = new LinkedList<Entry>();
        List<Entry> propertyValues = new LinkedList<Entry>();
        List<Entry> result = new LinkedList<Entry>();

        for (PermissionData p : data) {
            String permissionType = p.getType();
            Entry permissionEntry = javaObject(permissionType, null, baseDn);
            TimebasedOrderFilter.addId(permissionEntry, true);
            permissions.add(permissionEntry);

            for (EntryValue entryValue : p.getAttributes().values()) {
                String propertyKey = entryValue.getKey();
                Entry propertyEntry = namedObject(propertyKey, permissionEntry.getDn());
                properties.add(propertyEntry);

                for (EntryElement entryElement : entryValue.getValue()) {
                    String type = entryElement.getType();
                    String value = entryElement.getValue();
                    Entry propertyValueEntry = javaObject(type, value, propertyEntry.getDn());
                    TimebasedOrderFilter.addId(propertyValueEntry, true);
                    propertyValues.add(propertyValueEntry);
                }
            }
        }
        result.addAll(permissions);
        result.addAll(properties);
        result.addAll(propertyValues);
        return result;
    }
190638
function getParent(role) {
        var result = [];

        for (var parentRole in permissions) {
            if (permissions[parentRole].indexOf(role) > -1) {
                result.push(parentRole);
                result = result.concat(getParent(parentRole));
            }
        }
        return result;
    }
544257
public Object getProperty(String property) {
        try {
            return getProxyBuilder().doGetProperty(property);
        } catch (MissingPropertyException mpe) {
            if ((getContext() != null) && (getContext().containsKey(property))) {
                return getContext().get(property);
            } else {
                try {
                    return getMetaClass().getProperty(this, property);
                } catch(MissingPropertyException mpe2) {
                    if(mpe2.getProperty().equals(property) && propertyMissingDelegate != null) {
                        return propertyMissingDelegate.call(new Object[]{property});
                    }
                    throw mpe2;
                }
            }
        }
    }