Get all properties of the MessageFlags class.
764647
def get_properties(cls):
        """"""
        property_names = [p for p in dir(cls)
                          if isinstance(getattr(cls, p), property)]
        return property_names
1246100
private void readPropertiesFiles() {

        if (this.messageFileWildcard.isEmpty() || !CoreParameters.LOG_RESOLUTION.get()) {
            // Skip configuration loading
            LOGGER.info(JRebirthMarkers.MESSAGE, "Messages Loading is skipped");

        } else {
            // Assemble the regex pattern
            final Pattern filePattern = Pattern.compile(this.messageFileWildcard + "\\.properties");

            // Retrieve all resources from default classpath
            final Collection<String> list = ClasspathUtility.getClasspathResources(filePattern);

            LOGGER.info(JRebirthMarkers.MESSAGE, "{} Messages file{} found.", list.size(), list.size() > 1 ? "s" : "");

            for (final String rbFilename : list) {
                readPropertiesFile(rbFilename);
            }
        }
    }
1318241
def FlagValuesDict(self):
    """"""
    flag_values = {}

    for flag_name in self.RegisteredFlags():
      flag = self.FlagDict()[flag_name]
      flag_values[flag_name] = flag.value

    return flag_values
213133
public List<MetaProperty> getProperties() {
        checkInitalised();
        SingleKeyHashMap propertyMap = classPropertyIndex.getNullable(theCachedClass);
        if (propertyMap==null) {
            // GROOVY-6903: May happen in some special environment, like under Android, due
            // to classloading issues
            propertyMap = new SingleKeyHashMap();
        }
        // simply return the values of the metaproperty map as a List
        List ret = new ArrayList(propertyMap.size());
        for (ComplexKeyHashMap.EntryIterator iter = propertyMap.getEntrySetIterator(); iter.hasNext();) {
            MetaProperty element = (MetaProperty) ((SingleKeyHashMap.Entry) iter.next()).value;
            if (element instanceof CachedField) continue;
            // filter out DGM beans
            if (element instanceof MetaBeanProperty) {
                MetaBeanProperty mp = (MetaBeanProperty) element;
                boolean setter = true;
                boolean getter = true;
                if (mp.getGetter() == null || mp.getGetter() instanceof GeneratedMetaMethod || mp.getGetter() instanceof NewInstanceMetaMethod) {
                    getter = false;
                }
                if (mp.getSetter() == null || mp.getSetter() instanceof GeneratedMetaMethod || mp.getSetter() instanceof NewInstanceMetaMethod) {
                    setter = false;
                }
                if (!setter && !getter) continue;
//  TODO: I (ait) don't know why these strange tricks needed and comment following as it effects some Grails tests
//                if (!setter && mp.getSetter() != null) {
//                    element = new MetaBeanProperty(mp.getName(), mp.getType(), mp.getGetter(), null);
//                }
//                if (!getter && mp.getGetter() != null) {
//                    element = new MetaBeanProperty(mp.getName(), mp.getType(), null, mp.getSetter());
//                }
            }
            ret.add(element);
        }
        return ret;
    }
1254156
@Override
	public MessageProperties toMessageProperties(AMQP.BasicProperties source, Envelope envelope, String charset) {
		final MessageProperties messageProperties = super.toMessageProperties(source, envelope, charset);

		final TraceeFilterConfiguration filterConfiguration = backend.getConfiguration(profile);
		if (filterConfiguration.shouldProcessContext(AsyncProcess)) {
			// Values are stored as type of LongStringHelper.ByteArrayLongString - but it's private
			final Map<String, String> traceeContextMap = transformToTraceeContextMap(
				(Map<String, ?>) messageProperties.getHeaders().get(TPIC_HEADER));
			if (traceeContextMap != null && !traceeContextMap.isEmpty()) {
				backend.putAll(filterConfiguration.filterDeniedParams(traceeContextMap, AsyncProcess));
			}
		}

		Utilities.generateInvocationIdIfNecessary(backend);
		return messageProperties;
	}
252225
public Map<String,Object> getPayloadProperties(Object msg, Map<String,Class<?>> mapPropertyNames)
    {
        Map<String,Object> properties = new HashMap<String,Object>();
        
        for (String strKey : mapPropertyNames.keySet())
        {
            this.addPayloadProperty(msg, properties, strKey);            
        }
        this.addPayloadProperty(msg, properties, "Errors"); // For responses only            
        return properties;
    }
748167
def item_properties(self, handle):
        """"""
        logger.debug("Getting properties for handle: {}".format(handle))
        properties = {
            'size_in_bytes': self.get_size_in_bytes(handle),
            'utc_timestamp': self.get_utc_timestamp(handle),
            'hash': self.get_hash(handle),
            'relpath': self.get_relpath(handle)
        }
        logger.debug("{} properties: {}".format(handle, properties))
        return properties
1114974
def getElementProperties(self, name):
        
        try:
            allp = self.all_elements[name.upper()]
            if isinstance(allp, dict):
                type = allp.keys()[0]
                properties = allp.values()[0]
                return {'type': type, 'properties': properties}
            else:
                type = allp
                return {'type': type, 'properties': None}
        except:
            pass
888002
private function extractYedProperties()
	{
		foreach ($this->_mapper as $attrName => $xp) {
			$nodeList = $this->_xp->query($xp);
			if ($nodeList->length != 0) {
				$this->_yedProperties[$attrName] = $nodeList->item(0)->value;
			}
		}
	}
1121008
def _FetchCustomMappings(descriptor_ls):
    """"""
    custom_mappings = []
    for descriptor in descriptor_ls:
        if isinstance(descriptor, ExtendedEnumDescriptor):
            custom_mappings.extend(
                _FormatCustomJsonMapping('Enum', m, descriptor)
                for m in descriptor.enum_mappings)
        elif isinstance(descriptor, ExtendedMessageDescriptor):
            custom_mappings.extend(
                _FormatCustomJsonMapping('Field', m, descriptor)
                for m in descriptor.field_mappings)
            custom_mappings.extend(
                _FetchCustomMappings(descriptor.enum_types))
            custom_mappings.extend(
                _FetchCustomMappings(descriptor.message_types))
    return custom_mappings
454975
def bootstrap_message_classes(message):
    
    extra_tags = None
    try:
        extra_tags = message.extra_tags
    except AttributeError:
        pass
    if not extra_tags:
        extra_tags = ""
    classes = [extra_tags]
    try:
        level = message.level
    except AttributeError:
        pass
    else:
        try:
            classes.append(MESSAGE_LEVEL_CLASSES[level])
        except KeyError:
            classes.append("alert alert-danger")
    return " ".join(classes).strip()
1225683
def get_all_properties(self):
        
        properties = {
            prop_name: getattr(self, prop_name)
            for prop_name in self._property_list
        }

        return properties
978240
def get_matching_property_names(self, regex):
        
        log = logging.getLogger(self.cls_logger + '.get_matching_property_names')
        prop_list_matched = []
        if not isinstance(regex, basestring):
            log.warn('regex arg is not a string, found type: {t}'.format(t=regex.__class__.__name__))
            return prop_list_matched
        log.debug('Finding properties matching regex: {r}'.format(r=regex))
        for prop_name in self.properties.keys():
            match = re.search(regex, prop_name)
            if match:
                prop_list_matched.append(prop_name)
        return prop_list_matched
1133726
protected Map<String, CmsProperty> getActiveProperties() {

        // get all used properties for the resource
        if (m_activeProperties == null) {
            try {
                m_activeProperties = CmsPropertyAdvanced.getPropertyMap(
                    getCms().readPropertyObjects(getParamResource(), false));
            } catch (CmsException e) {
                // create an empty list
                if (LOG.isInfoEnabled()) {
                    LOG.info(e.getLocalizedMessage());
                }
                m_activeProperties = new HashMap<String, CmsProperty>();
            }
        }
        return m_activeProperties;
    }
1162120
static public String[] getAllProperties() {
        java.util.Properties prop = System.getProperties();
        java.util.ArrayList<String> list = new java.util.ArrayList<String>();
        java.util.Enumeration<?> enumeration = prop.propertyNames();
        while (enumeration.hasMoreElements()) {
            list.add((String)enumeration.nextElement());
        }
        return list.toArray(new String[0]);
    }
1309394
private static String[] getMessageTypesFromMpClass(final Class<?> mpClass) {
        final String[] classAnn = getAllMessageTypeTypeAnnotationValues(mpClass, false);

        // Find all of the handle methods and introspect their parameters.
        final String[] methAnn = AnnotatedMethodInvoker.introspectAnnotationMultiple(mpClass, MessageHandler.class).stream()
                .map(m -> getAllMessageTypeTypeAnnotationValues(m.getParameterTypes()[0], false)).map(Arrays::stream).flatMap(v -> v)
                .toArray(String[]::new);

        return Arrays.stream(new String[][] { classAnn, methAnn }).map(Arrays::stream).flatMap(v -> v).toArray(String[]::new);
    }
256233
def properties(self):
        
        return {
            "customAnnotatorClass.{}".format(self.name): "edu.stanford.nlp.pipeline.GenericWebServiceAnnotator",
            "generic.endpoint": "http://{}:{}".format(self.host, self.port),
            "generic.requires": ",".join(self.requires),
            "generic.provides": ",".join(self.provides),
            }