Adds the meta modifier.

@param keyEventMetaModifier Native Android modifier value. Multiple modifiers can
be combined into a single key event.
@return self instance for chaining
552491
public KeyEvent withMetaModifier(KeyEventMetaModifier keyEventMetaModifier) {
        if (this.metaState == null) {
            this.metaState = 0;
        }
        this.metaState |= keyEventMetaModifier.getValue();
        return this;
    }
1040457
public function add_metadata_manifest(cc_i_metadata_manifest $met) {
        $metanode = $this->node("//imscc:manifest[@identifier='".
                                $this->activemanifest->manifestID().
                                "']/imscc:metadata");
        $nmeta = $this->activemanifest->create_metadata_node($met, $this->doc, $metanode);
        $metanode->appendChild($nmeta);
    }
167357
public function setMeta(string $key, $value): MetaAwareInterface
    {
        //convert pluginAnnotation meta to correct key:value pair
        if ($value instanceof PluginConfigAnnotation) {
            $key = $value->getName();
            $value = $value->getConfig();
        }

        $this->metas[$key] = $value;

        return $this;
    }
1350909
public void addModifier(String modifier) {
		if (!Strings.isEmpty(modifier)) {
			this.sarlInterface.getModifiers().add(modifier);
		}
	}
486426
public void addModifier(String modifier) {
		if (!Strings.isEmpty(modifier)) {
			this.sarlBehavior.getModifiers().add(modifier);
		}
	}
726760
public ContentMetadata addCustomMetadata(String key, String value) {
        customMetadata.put(key, value);
        return this;
    }
1200859
public Application withMetadata(java.util.Map<String, String> metadata) {
        setMetadata(metadata);
        return this;
    }
1048240
public function setMeta($key, $value = null)
	{
		if(is_array($key))
		{
			$this->meta = array_merge($this->meta, $key);
			return $this;
		}

		$this->meta[$key] = $value;

		return $this;
	}
1045989
def meta_set(self, key, metafield, value):
        
        self._meta.setdefault(key, {})[metafield] = value
990156
public KeyEvent withFlag(KeyEventFlag keyEventFlag) {
        if (this.flags == null) {
            this.flags = 0;
        }
        this.flags |= keyEventFlag.getValue();
        return this;
    }
491919
protected function addMetaData($event, array $metaData)
    {
        if (is_array($metaData) && count($metaData)) {
            foreach ($metaData as $key => $metaDatum) {
                $method = 'set' . ucfirst($key);

                if (method_exists($event, $method)) {
                    $event->$method($metaDatum);
                }
            }
        }
    }
976612
public static <T> Meta<T> meta() {
    return new Meta<>(MetaConfig.defaultConfig(), null, TYPED_PROPERTY_ARRAYS.empty(), TYPED_STRING_ARRAYS.empty());
  }
960840
public void addColumnMeta(ColumnMeta columnMeta) {
    columnMetas.add(columnMeta);
    columnMeta.setTableMeta(this);
    if (columnMeta.isPrimaryKey()) {
      primaryKeyColumnMetas.add(columnMeta);
    }
  }
1244904
public static void addContextHandlerMeta(final ContextHandlerMeta contextHandlerMeta) {
        final Method invokeHolder = contextHandlerMeta.getInvokeHolder();
        final Class<?> returnType = invokeHolder.getReturnType();
        final String methodName = invokeHolder.getDeclaringClass().getName() + "#" + invokeHolder.getName();

        if (!void.class.equals(returnType)) {
            LOGGER.error("Handler method [" + methodName + "] must return void");
            System.exit(-1);
        }
        final Class<?>[] exceptionTypes = invokeHolder.getExceptionTypes();
        if (0 < exceptionTypes.length) {
            LOGGER.error("Handler method [" + methodName + "] can not throw exceptions");
            System.exit(-1);
        }
        final Class<?>[] parameterTypes = invokeHolder.getParameterTypes();
        if (1 != parameterTypes.length) {
            LOGGER.error("Handler method [" + methodName + "] must have one parameter with type [RequestContext]");
            System.exit(-1);
        }
        final Class<?> parameterType = parameterTypes[0];
        if (!RequestContext.class.equals(parameterType)) {
            LOGGER.error("Handler method [" + methodName + "] must have one parameter with type [RequestContext]");
            System.exit(-1);
        }

        final HttpMethod[] httpMethods = contextHandlerMeta.getHttpMethods();
        for (int i = 0; i < httpMethods.length; i++) {
            final String httpMethod = httpMethods[i].name();
            final String[] uriTemplates = contextHandlerMeta.getUriTemplates();
            for (int j = 0; j < uriTemplates.length; j++) {
                final String uriTemplate = uriTemplates[j];
                final String key = httpMethod + "." + uriTemplate;
                final int segs = StringUtils.countMatches(uriTemplate, "/");
                if (!StringUtils.contains(uriTemplate, "{")) {
                    switch (segs) {
                        case 1:
                            ONE_SEG_CONCRETE_CTX_HANDLER_METAS.put(key, contextHandlerMeta);
                            break;
                        case 2:
                            TWO_SEG_CONCRETE_CTX_HANDLER_METAS.put(key, contextHandlerMeta);
                            break;
                        case 3:
                            THREE_SEG_CONCRETE_CTX_HANDLER_METAS.put(key, contextHandlerMeta);
                            break;
                        default:
                            FOUR_MORE_SEG_CONCRETE_CTX_HANDLER_METAS.put(key, contextHandlerMeta);
                    }
                } else { // URI templates contain path vars
                    switch (segs) {
                        case 1:
                            switch (httpMethod) {
                                case "GET":
                                    ONE_SEG_GET_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "POST":
                                    ONE_SEG_POST_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "PUT":
                                    ONE_SEG_PUT_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "DELETE":
                                    ONE_SEG_DELETE_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                default:
                                    ONE_SEG_OTHER_METHOD_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                            }

                            break;
                        case 2:
                            switch (httpMethod) {
                                case "GET":
                                    TWO_SEG_GET_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "POST":
                                    TWO_SEG_POST_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "PUT":
                                    TWO_SEG_PUT_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "DELETE":
                                    TWO_SEG_DELETE_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                default:
                                    TWO_SEG_OTHER_METHOD_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                            }

                            break;
                        case 3:
                            switch (httpMethod) {
                                case "GET":
                                    THREE_SEG_GET_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "POST":
                                    THREE_SEG_POST_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "PUT":
                                    THREE_SEG_PUT_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "DELETE":
                                    THREE_SEG_DELETE_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                default:
                                    THREE_SEG_OTHER_METHOD_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                            }

                            break;
                        default:
                            switch (httpMethod) {
                                case "GET":
                                    FOUR_MORE_SEG_GET_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "POST":
                                    FOUR_MORE_SEG_POST_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "PUT":
                                    FOUR_MORE_SEG_PUT_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                case "DELETE":
                                    FOUR_MORE_SEG_DELETE_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                                    break;
                                default:
                                    FOUR_MORE_SEG_OTHER_METHOD_VAR_CTX_HANDLER_METAS.put(uriTemplate, contextHandlerMeta);
                            }
                    }
                }
            }
        }

        LOGGER.log(Level.DEBUG, "Added a processor method [" + methodName + "]");
    }
716269
public function setModifier(EventManagerAwareInterface $modifier)
    {
        $this->modifier = $modifier;
        $this->builder->setModifier($modifier);
        
        return $this;
    }
1059734
public void addMetaBeanProperty(MetaBeanProperty mp) {

        MetaProperty staticProperty = establishStaticMetaProperty(mp);
        if (staticProperty != null) {
            staticPropertyIndex.put(mp.getName(), mp);
        } else {

            SingleKeyHashMap propertyMap = classPropertyIndex.getNotNull(theCachedClass);
            //keep field
            CachedField field;
            MetaProperty old = (MetaProperty) propertyMap.get(mp.getName());
            if (old != null) {
                if (old instanceof MetaBeanProperty) {
                    field = ((MetaBeanProperty) old).getField();
                } else if (old instanceof MultipleSetterProperty) {
                    field = ((MultipleSetterProperty)old).getField();
                } else {
                    field = (CachedField) old;
                }
                mp.setField(field);
            }

            // put it in the list
            // this will overwrite a possible field property
            propertyMap.put(mp.getName(), mp);
        }

    }
1308749
public void meta(MetaMessage meta) {
		//System.out.println("Meta Message detected : " + meta.getType());
		if (meta.getType()==MidiMessageType.TEMPO_CHANGE ||
				// Work around part with generic meta message work around
				(meta.getType()==MidiMessageType.MARKER && MetaMessageWA.isTempoMessage(meta))
				) {
			int expectdNotesNbPerMn = TempoMessage.getTempo(meta.getData()).getNotesNumberPerMinute();
			//System.out.println("detected tempo change : " + expectdNotesNbPerMn +
			//		" current seq tempo : " + seq.getTempoInBPM());
			// Work around for JDK 1.5 (seems to work in JDK 1.4....)
			if ((int)seq.getTempoInBPM()!=expectdNotesNbPerMn)
				seq.setTempoInBPM(expectdNotesNbPerMn);
			notifyForTempoChange((int)seq.getTempoInBPM());
		}
		else
			if (meta.getType()==MidiMessageType.NOTE_INDEX_MARKER) {
				//FIXME notifyNotePlayedChange, use MusicReference? what is NoteIndexMessage.getIndex
				//notifyNotePlayedChanged((NoteAbstract)m_tune.getMusic().elementAt(NoteIndexMessage.getIndex(meta.getData())));
			}
			else
				if (MetaMessageWA.isNotationMarker(meta)) {
					//System.out.println("NOTATION MARKER");
					int begin = NotationMarkerMessage.getBeginOffset(meta.getData());
					int end = NotationMarkerMessage.getEndOffset(meta.getData());
					notifyForPartPlayedChanged (begin, end);
				}
				else
					if (meta.getType()==MidiMessageType.END_OF_TRACK) {
						notifyForPlayEnd();
					}
  }