Retrieve the meta value of a certain key
544570
public function getMeta($key)
    {
    	$taxonomymeta = $this->taxonomymeta;
    	$taxonomymeta = $taxonomymeta->keyBy('meta_key');
		if(array_has($taxonomymeta, $key . '.meta_value')){
			$returnValue = $taxonomymeta[$key]['meta_value'];
			return $returnValue;
		}
    }
1045098
def _get_metadata_as_string(self):
        """"""
        metalist = []
        for metaname, meta in iteritems(self.metadata):
            message = "Single value in metadata dictionary should be a list!"
            assert isinstance(meta, list), message
            for data in meta:
                if data:
                    metalist.append("!%s_%s = %s" % (self.geotype.capitalize(),
                                                     metaname, data))
        return "\n".join(metalist)
866859
def meta(cls):
        """"""
        if getattr(cls, '__from_class__', None) is not None:
            cls = cls.__from_class__
        attribute_info = {}
        for name, value in cls.__table__.columns.items():
            attribute_info[name] = str(value.type).lower()

        return {cls.__name__: attribute_info}
321507
def parse_meta(meta):
    
    resources = {}
    for name in meta:
        if name.startswith("$"):
            continue
        resources[name] = resource = {}
        for action in meta[name]:
            if action.startswith("$"):
                continue
            url, httpmethod = res_to_url(name, action)
            resource[action] = {
                "url": url,
                "method": httpmethod
            }
    url_prefix = meta.get("$url_prefix", "").rstrip("/")
    return url_prefix, meta["$auth"]["header"].lower(), resources
1153840
function meta( $key )
    {
        $content = array();
        if ( file_exists( $this->MetaFileName ) )
        {
            $content = unserialize( file_get_contents( $this->MetaFileName ) );
        }
        return isset( $content[$key] ) ? $content[$key] : null;
    }
248298
public function get_meta( $key ) {
		$metadata = $this->get_metadata();

		if ( ! array_key_exists( $key, $metadata ) ) {
			return;
		}

		return $metadata[ $key ];
	}
749123
private static ObjectMetadata getObjectMetadataForKey(Key k) {
    String[] bk = decodeKey(k);
    assert (bk.length == 2);
    return getClient().getObjectMetadata(bk[0], bk[1]);
  }
702584
def find_meta(meta):
    
    meta_match = re.search(
        r"^__{meta}__ = ['\"]([^'\"]*)['\"]".format(meta=meta),
        META_FILE, re.M
    )
    if meta_match:
        return meta_match.group(1)
    raise RuntimeError("Unable to find __{meta}__ string.".format(meta=meta))
919289
public function getMetadata($key = null)
    {
        $meta = stream_get_meta_data($this->buffer);

        if (!isset($key)) {
            return $meta;
        }

        if (isset($meta[$key])) {
            return $meta[$key];
        }
    }
61102
public function getMetaValue($metaKey)
    {
        $metas = $this->getMeta();
        foreach ($metas as $meta)
        {
            if ($meta->getMetaKey() == $metaKey)
            {
                return ($meta->getMetaValue());
            }
        }
        return '';
    }
278652
public function getMetaValue($name)
    {
        /** @var PostMeta $meta */
        foreach ($this->getMetas() as $meta) {
            if ($name == $meta->getKey()) {
                return $meta->getValue();
            }
        }

        return;
    }
1321500
def get_meta(request, pid):
    """"""
    d1_gmn.app.event_log.log_read_event(pid, request)
    return django.http.HttpResponse(
        d1_gmn.app.views.util.generate_sysmeta_xml_matching_api_version(request, pid),
        d1_common.const.CONTENT_TYPE_XML,
    )
654483
def get_by(self, prop, val, raise_exc=False):
        ''''''
        try:
            val = self.serialize(val)
            return self._meta[prop][val][0]
        except (KeyError, IndexError):
            if raise_exc:
                raise
            else:
                return None
1196930
def _ReadStorageMetadata(self):
    """"""
    query = 'SELECT key, value FROM metadata'
    self._cursor.execute(query)

    metadata_values = {row[0]: row[1] for row in self._cursor.fetchall()}

    self._compression_format = metadata_values['compression_format']
14506
def metadataURL(self, value):
        """"""
        if value != self._metadataURL:
            self._metadataURL = value
            self._metaFS = None
624386
public function load_meta()
	{
		if ( empty( $this->attributes ) ) return;

		foreach ( get_post_meta( $this->attributes['ID'] ) as $key => $value ) {
			if ( ! preg_match( '/_wp_/', $key )
				|| in_array( 'meta_' . $key, $this->aliases )
			) {
				$value = $value[0];

				$this->meta[$key] = is_string( $value )
					? ( preg_match( '/_wp_/', $key )
						? $value
						: json_decode( $value )
					)
					: ( is_integer( $value )
						? intval( $value )
						: floatval( $value )
					);
			}
		}
	}
773407
public function getMetaData($key)
    {
        return isset($this->meta[$key]) ? $this->meta[$key] : null;
    }