Get the type created by selecting only a subset of properties from this
type. The type must be a map for this to work

@param properties The properties to select
@return The new type definition
766878
public JsonTypeDefinition projectionType(String... properties) {
        if(this.getType() instanceof Map<?, ?>) {
            Map<?, ?> type = (Map<?, ?>) getType();
            Arrays.sort(properties);
            Map<String, Object> newType = new LinkedHashMap<String, Object>();
            for(String prop: properties)
                newType.put(prop, type.get(prop));
            return new JsonTypeDefinition(newType);
        } else {
            throw new IllegalArgumentException("Cannot take the projection of a type that is not a Map.");
        }
    }
564285
@Nonnull
  public static NonBlockingProperties create (@Nullable final Map <?, ?> aProperties)
  {
    final NonBlockingProperties ret = new NonBlockingProperties ();
    if (aProperties != null)
      for (final Map.Entry <?, ?> aEntry : aProperties.entrySet ())
        ret.put ((String) aEntry.getKey (), (String) aEntry.getValue ());
    return ret;
  }
299555
public Type getPropertyType(String property) {
    Type type = (Type) propertyTypes.get(property);
    if (null == type) {
      Class<?> propertyType = PropertyUtils.getPropertyType(entityClass, property);
      if (null != propertyType) {
        if (Entity.class.isAssignableFrom(propertyType)) type = new EntityType(propertyType);
        if (propertyType.isInterface()) type = Model.getType(propertyType.getName());
        if (null == type) type = new IdentifierType(propertyType);
      }
    }
    if (null == type) logger.error("{} doesn't contains property {}", entityName, property);
    return type;
  }
86166
public <A, E> ArrayPath<A, E> getArray(String property, Class<A> type) {
        validate(property, Array.newInstance(type, 0).getClass());
        return super.createArray(property, type);
    }
78167
public static PropertyBuilder getInstance(Context context,
            TypeElement typeElement,
            PropertyWriter writer) {
        return new PropertyBuilder(context, typeElement, writer);
    }
70042
@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public PrefixedPropertiesEnumeration<?> propertyNames() {
		lock.readLock().lock();
		try {
			final Set result = new HashSet();
			for (final Object key : getKeyMap(false).keySet()) {
				result.add(getUnprefixedKey(key));
			}
			return new PrefixedPropertiesEnumerationImpl(result.iterator(), true);
		} finally {
			lock.readLock().unlock();
		}
	}
960224
public PropertyType getPropertyType(String field) {
        if(propertyTypes==null)
            propertyTypes = buildPropertyTypes(clazz);
        return propertyTypes.get(field);
    }
1047601
public PropertyType<ConnectionFactoryResourceType<T>> getOrCreateProperty()
   {
      List<Node> nodeList = childNode.get("property");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new PropertyTypeImpl<ConnectionFactoryResourceType<T>>(this, "property", childNode, nodeList.get(0));
      }
      return createProperty();
   }
753748
public Map<String, Object> getProperties() {
        // Shallow copy entries to a newly instantiated HashMap.
        Map<String, Object> clone = new HashMap<String, Object>();
        Set<Entry<String, Object>> set = _properties.entrySet();
        
        for (Entry<String, Object> entry : set) {
            // There wouldn't be any entry with a null value.
            clone.put(entry.getKey(), entry.getValue());
        }
        
        return clone;
    }
817178
public synchronized Map<String, Object> getProperties() {
        if (properties == null) {
            return Collections.emptyMap();
        }
        return Collections.unmodifiableMap(new HashMap<>(properties));
    }
1197941
public ClassSelector except(String... propertyNames) {
    if(ArrayUtils.isEmpty(propertyNames)){
      return this;
    }

    boolean updated = false;
    for (String propertyToRemove : propertyNames) {
      if (removePropertySelector(propertyToRemove)) {
        updated = true;
      }
    }

    if (updated) {
      compositeSelector = new CompositeSelector(this.propertySelectors);
    }
    return this;
  }
1033368
private Map<String, Object> getProperties(GDLParser.PropertiesContext propertiesContext) {
    if (propertiesContext != null) {
      Map<String, Object> properties = new HashMap<>();
      for (GDLParser.PropertyContext property : propertiesContext.property()) {
        properties.put(property.Identifier().getText(), getPropertyValue(property.literal()));
      }
      return properties;
    }
    return Collections.emptyMap();
  }
1285851
@Deprecated
  public ProjectDefinition setProperties(Properties properties) {
    for (Entry<Object, Object> entry : properties.entrySet()) {
      this.properties.put(entry.getKey().toString(), entry.getValue().toString());
    }
    return this;
  }
1126391
public PropertySet addAll( Iterator<String> properties)
    {
    if( properties != null)
      {
      while( properties.hasNext())
        {
        add( properties.next());
        }
      }

    return this;
    }
689164
public static TypedProperties toTypedProperties(Properties p) {
      if (p instanceof TypedProperties) return (TypedProperties) p;
      return new TypedProperties(p);
   }
709397
private JSType joinRecordTypes(ImmutableList<ObjectType> recTypes) {
    Map<String, JSType> props = new LinkedHashMap<>();
    for (ObjectType recType : recTypes) {
      for (String newPropName : recType.getOwnPropertyNames()) {
        JSType newPropValue = recType.getPropertyType(newPropName);
        // Put the new property depending if it already exists in the map
        putNewPropInPropertyMap(props, newPropName, newPropValue);
      }
    }
    return createRecordType(ImmutableMap.copyOf(props));
  }
806460
public Map<String, Object> getApplicationProperties(Map<String, Object> properties)
    {
        if (properties == null)
            return null;
        Map<String, Object> propApp = new Hashtable<String,Object>();
        if (properties.get(DBParams.LANGUAGE) != null)
            propApp.put(DBParams.LANGUAGE, properties.get(DBParams.LANGUAGE));
        if (properties.get(DBParams.DOMAIN) != null)
            propApp.put(DBParams.DOMAIN, properties.get(DBParams.DOMAIN));
        return propApp;
    }