Returns all the properties of this layout, in their proper order.
489443
public List<LayoutProperty> getAllProperties() throws FetchException {
        List<LayoutProperty> all = mAllProperties;

        if (all == null) {
            Cursor <StoredLayoutProperty> cursor = mLayoutFactory.mPropertyStorage
                .query("layoutID = ?")
                .with(mStoredLayout.getLayoutID())
                .orderBy("ordinal")
                .fetch();

            try {
                List<LayoutProperty> list = new ArrayList<LayoutProperty>();

                while (cursor.hasNext()) {
                    list.add(new LayoutProperty(cursor.next()));
                }

                mAllProperties = all = Collections.unmodifiableList(list);
            } finally {
                cursor.close();
            }
        }

        return all;
    }
1225683
def get_all_properties(self):
        
        properties = {
            prop_name: getattr(self, prop_name)
            for prop_name in self._property_list
        }

        return properties
259643
public List<String> getPropertyNames() {
        ArrayList<String> names = new ArrayList<>(properties.keySet());
        Collections.sort(names);
        return names;
    }
893496
public Map getProperties()
    {
        Map properties = super.getProperties();
        if (m_propertiesForFilter != null)
            properties.putAll(m_propertiesForFilter);
        return properties;
    }
808514
def _get_layout(self):
        
        connected = list()
        active_layout = list()
        disconnected = list()
        layout = OrderedDict(
            {"connected": OrderedDict(), "disconnected": OrderedDict()}
        )

        current = self.py3.command_output("xrandr")
        for line in current.splitlines():
            try:
                s = line.split(" ")
                infos = line[line.find("(") :]
                if s[1] == "connected":
                    output, state, mode = s[0], s[1], None
                    for index, x in enumerate(s[2:], 2):
                        if "x" in x and "+" in x:
                            mode = x
                            active_layout.append(output)
                            infos = line[line.find(s[index + 1]) :]
                            break
                        elif "(" in x:
                            break
                    connected.append(output)
                elif s[1] == "disconnected":
                    output, state, mode = s[0], s[1], None
                    disconnected.append(output)
                else:
                    continue
            except Exception as err:
                self.py3.log('xrandr error="{}"'.format(err))
            else:
                layout[state][output] = {"infos": infos, "mode": mode, "state": state}

        # initialize the active layout
        if self.active_layout is None:
            self.active_comb = tuple(active_layout)
            self.active_layout = self._get_string_and_set_width(
                tuple(active_layout), self.active_mode
            )

        return layout
734504
public Map<String, Object> getProperties()
    {
        Record recUserRegistration = this.getUserRegistration();
        return ((PropertiesField)recUserRegistration.getField(UserRegistrationModel.PROPERTIES)).getProperties();
    }
568830
def items( self ):
        
        layout = self.widget().layout()
        return [layout.itemAt(i).widget() for i in range(layout.count()-1)]
403506
def _get_schema(self):
		
		d={}
		layout_kwargs=dict((_,'') for _ in get_layout_kwargs())
		for _ in ('data','layout','theme','panels'):
			d[_]={}
			for __ in eval('__QUANT_FIGURE_{0}'.format(_.upper())):
				layout_kwargs.pop(__,None)
				d[_][__]=None
		d['layout'].update(annotations=dict(values=[],
											params=utils.make_dict_from_list(get_annotation_kwargs())))
		d['layout'].update(shapes=utils.make_dict_from_list(get_shapes_kwargs()))
		[layout_kwargs.pop(_,None) for _ in get_annotation_kwargs()+get_shapes_kwargs()]
		d['layout'].update(**layout_kwargs)
		return d
385371
public Collection<String> getAllProperties() {
		return wrappedSubmit(new Callable<Collection<String>>() {
			@Override
			public Collection<String> call() throws Exception {
				Collection<String> allProperties = new HashSet<String>();
				ObjectMapper mapper = new ObjectMapper();
				List<XmlProperty> xmlproperties = new ArrayList<XmlProperty>();
				try {xmlproperties = mapper.readValue(
										service.path(resourceProperties)
										.accept(MediaType.APPLICATION_JSON)
										.get(String.class)	
									,new TypeReference<List<XmlProperty>>(){});
				} catch (JsonParseException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (JsonMappingException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ClientHandlerException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				for (XmlProperty xmlproperty : xmlproperties) {
					allProperties.add(xmlproperty.getName());
				}
				return allProperties;
			}
		});
	}
1293402
def layout(self):
                
                ret = []
                for row in self.rows:
                        if len(row) > len(ret):
                                ret += [0] * (len(row) - len(ret))
                        for n, field in enumerate(row):
                                if field is self.empty_value:
                                        field = ''
                                ret[n] = max(ret[n], len(field))
                return ret
527601
def properties(self):
        
        if self._property_manager is None:
            self._property_manager = PropertyManager(session=self._session)
        return self._property_manager
644223
public List<PropertyType<ConnectionFactoryResourceType<T>>> getAllProperty()
   {
      List<PropertyType<ConnectionFactoryResourceType<T>>> list = new ArrayList<PropertyType<ConnectionFactoryResourceType<T>>>();
      List<Node> nodeList = childNode.get("property");
      for(Node node: nodeList)
      {
         PropertyType<ConnectionFactoryResourceType<T>>  type = new PropertyTypeImpl<ConnectionFactoryResourceType<T>>(this, "property", childNode, node);
         list.add(type);
      }
      return list;
   }
630035
@SuppressWarnings("unchecked")
    public OrderedProperty<S>[] getOrderedProperties() {
        OrderedProperty<S>[] ordered = new OrderedProperty[mProperties.length];
        for (int i=mProperties.length; --i>=0; ) {
            ordered[i] = OrderedProperty.get(mProperties[i], mDirections[i]);
        }
        return ordered;
    }
646719
public LayoutParams getLayoutParams() {
        if (mLayoutParams == null) {
            mLayoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        }
        return mLayoutParams;
    }
631214
def layout_json_names(self):
        """"""
        if self._layout_json_names is None:
            self._layout_json_names = self.layout_json_params.keys()
        return self._layout_json_names
905462
public final MapDictionary<String, Object> getProperties() {
        if (this.properties.isReadyOnly()) {
            return this.properties;
        }
        return new MapDictionary<String, Object>(this.properties);
    }
569649
public Properties getSystemProperties() {

    Properties properties = new Properties();     
    properties.putAll(System.getenv());
    properties.putAll(System.getProperties());

    return properties;
  }