This method adds the given {@code accessor} to the given {@code propertyDescriptor}.

@param propertyDescriptor is the descriptor of the property where to add the given {@code accessor}.
@param accessor is the (virtual) accessor to add.
163750
private void addVirtualAccessor(AbstractPojoPropertyDescriptor propertyDescriptor, PojoPropertyAccessor accessor) {

    LOG.trace("adding virtual accessor: {}", accessor);
    propertyDescriptor.putAccessor(accessor);
  }
131494
@SuppressWarnings("unchecked")
  public void addRepeatedField(final FieldDescriptorType descriptor,
                               final Object value) {
    if (!descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "addRepeatedField() can only be called on repeated fields.");
    }

    verifyType(descriptor.getLiteType(), value);

    final Object existingValue = getField(descriptor);
    List<Object> list;
    if (existingValue == null) {
      list = new ArrayList<Object>();
      fields.put(descriptor, list);
    } else {
      list = (List<Object>) existingValue;
    }

    list.add(value);
  }
352488
static Accessor accessorFor(Class<?> type, String accessorName, InheritingConfiguration configuration) {
    PropertyInfoKey key = new PropertyInfoKey(type, accessorName, configuration);
    if (!ACCESSOR_CACHE.containsKey(key) || !FIELD_CACHE.containsKey(key)) {
      @SuppressWarnings("unchecked")
      Class<Object> uncheckedType = (Class<Object>) type;
      for (Entry<String, Accessor> entry : TypeInfoRegistry.typeInfoFor(uncheckedType, configuration).getAccessors().entrySet()) {
        if (entry.getValue().getMember() instanceof Method)
          accessorFor(type, (Method) entry.getValue().getMember(), configuration, entry.getKey());
        else if (entry.getValue().getMember() instanceof Field)
          fieldPropertyFor(type, (Field) entry.getValue().getMember(), configuration, entry.getKey());
      }
    }

    if (ACCESSOR_CACHE.containsKey(key))
      return ACCESSOR_CACHE.get(key);
    return FIELD_CACHE.get(key);
  }
197264
function updateDescriptor(newDescriptor, options) {

	var descriptor,
		typeTest,
		eventType;
	
	if (newDescriptor) {
		if (!currentProperty)
			throw exception('name');
		
		descriptor = newDescriptor;
	}
	
	if (options) {
		if (!currentProperty)
			throw exception('property');
		
		descriptor = getCurrentDescriptor();
		
		if (options.type)
			typeTest = getTestFor(options.type);
		
		if (options.event)
			eventType = options.event === true ? ProtoTyper.CHANGE : options.event;
		
		if (descriptor.hasOwnProperty('value') && (typeTest || eventType)) {
			// We need to define a "private" variable.
			push(currentTarget, '_'+currentProperty, {
				'value': descriptor.value,
				'enumerable': false,
				'writable': true
			});
			delete descriptor.value;
		}
		
		if (descriptor.hasOwnProperty('writable') && (typeTest || eventType))
			delete descriptor.writable;
		
		if (typeTest || eventType) {
			descriptor.get = generateGet(currentProperty);
			descriptor.set = generateSet(descriptor.set, currentProperty, typeTest, eventType);
		}
		
		if (options.notKey)
			descriptor.enumerable = false;
		
		if (options.final)
			descriptor.configurable = false;
	}
	
	
	push(currentTarget, currentProperty, descriptor);
}
667489
protected void addProperties(Element element, BeanDefinitionBuilder builder) {
        NamedNodeMap attributes = element.getAttributes();
        
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            String attrName = getNodeName(node);
            attrName = "class".equals(attrName) ? "clazz" : attrName;
            builder.addPropertyValue(attrName, node.getNodeValue());
        }
    }
357092
private void addProperties(BaseProfileDescriptor pomDescriptor, Properties properties, Store store) {
        Set<Entry<Object, Object>> entrySet = properties.entrySet();
        for (Entry<Object, Object> entry : entrySet) {
            PropertyDescriptor propertyDescriptor = store.create(PropertyDescriptor.class);
            propertyDescriptor.setName(entry.getKey().toString());
            propertyDescriptor.setValue(entry.getValue().toString());
            pomDescriptor.getProperties().add(propertyDescriptor);
        }

    }
881364
public void setDescriptor(String descriptor)
  {
    _descriptor = descriptor;

    if (_jClass != null)
      _jClass.getConstantPool().addUTF8(descriptor);
  }
343504
def alias_property_accessors(property)
      # the Java reader and writer accessor method symbols
      jra, jwa = property.java_accessors
      # strip the Java reader and writer is/get/set prefix and make a symbol
      alias_method(property.reader, jra)
      alias_method(property.writer, jwa)
    end
678183
public void assignProvidedProperties(final ComponentDescriptor<?> descriptor, final Object component) {
        final Set<ProvidedPropertyDescriptor> providedDescriptors = descriptor.getProvidedProperties();
        for (final ProvidedPropertyDescriptor providedDescriptor : providedDescriptors) {

            final InjectionPoint<Object> injectionPoint = new PropertyInjectionPoint(providedDescriptor, component);
            final Object value = _injectionManager.getInstance(injectionPoint);
            providedDescriptor.setValue(component, value);

        }
    }
1139411
@Nonnull
    public BugInstance addClassAndMethod(MethodDescriptor methodDescriptor) {
        addClass(ClassName.toDottedClassName(methodDescriptor.getSlashedClassName()));
        add(MethodAnnotation.fromMethodDescriptor(methodDescriptor));
        return this;
    }
814385
@SuppressWarnings({"unchecked", "rawtypes"})
  public void setField(final FieldDescriptorType descriptor,
                       Object value) {
    if (descriptor.isRepeated()) {
      if (!(value instanceof List)) {
        throw new IllegalArgumentException(
          "Wrong object type used with protocol message reflection.");
      }

      // Wrap the contents in a new list so that the caller cannot change
      // the list's contents after setting it.
      final List newList = new ArrayList();
      newList.addAll((List) value);
      for (final Object element : newList) {
        verifyType(descriptor.getLiteType(), element);
      }
      value = newList;
    } else {
      verifyType(descriptor.getLiteType(), value);
    }

    if (value instanceof LazyField) {
      hasLazyField = true;
    }
    fields.put(descriptor, value);
  }
1012725
public boolean addDescriptor() {

        saveLocalization();
        IndexedContainer oldContainer = m_container;
        try {
            createAndLockDescriptorFile();
            unmarshalDescriptor();
            updateBundleDescriptorContent();
            m_hasMasterMode = true;
            m_container = createContainer();
            m_editorState.put(EditMode.DEFAULT, getDefaultState());
            m_editorState.put(EditMode.MASTER, getMasterState());
        } catch (CmsException | IOException e) {
            LOG.error(e.getLocalizedMessage(), e);
            if (m_descContent != null) {
                m_descContent = null;
            }
            if (m_descFile != null) {
                m_descFile = null;
            }
            if (m_desc != null) {
                try {
                    m_cms.deleteResource(m_desc, CmsResourceDeleteMode.valueOf(1));
                } catch (CmsException ex) {
                    LOG.error(ex.getLocalizedMessage(), ex);
                }
                m_desc = null;
            }
            m_hasMasterMode = false;
            m_container = oldContainer;
            return false;
        }
        m_removeDescriptorOnCancel = true;
        return true;
    }
1245760
public void assignConfiguredProperties(final ComponentDescriptor<?> descriptor, final Object component,
            final ComponentConfiguration componentConfiguration) {
        final AssignConfiguredPropertiesHelper helper = new AssignConfiguredPropertiesHelper();
        helper.assignProperties(component, descriptor, componentConfiguration);
    }
525616
protected  <P> void addMapping(K columnKey, ColumnDefinition<K, ?> columnDefinition,  PropertyMeta<T, P> prop) {
		propertyMappingsBuilder.addProperty(columnKey, columnDefinition, prop);
	}
276342
@Override
    protected void fillConstructorProperties(IdFunctionObject ctor)
    {
        ctor.put("BYTES_PER_ELEMENT", ctor, ScriptRuntime.wrapInt(getBytesPerElement()));
    }
1098380
function(descriptor) {
					var newDescriptor = {
						get: descriptor.get,
						set: function(val) {
							if (fnIsACBUrl(val)) {
								val = fnConvertUrl(val);
							}
							descriptor.set.call(this, val);
						},
						enumerable: descriptor.enumerable,
						configurable: descriptor.configurable
					};
					newDescriptor.set._sapUiCoreACB = true;
					return newDescriptor;
				}
523573
private static Properties readPropertiesFromDescriptor(ArquillianDescriptor descriptor) {
        for (ExtensionDef extension : descriptor.getExtensions()) {
            if (CitrusExtensionConstants.CITRUS_EXTENSION_QUALIFIER.equals(extension.getExtensionName())) {
                Properties properties = new Properties();
                properties.putAll(extension.getExtensionProperties());
                return properties;
            }
        }

        return new Properties();
    }