Query all the raw object data for an specific class

@param wmiClass
string with the name of the class to query
@return string with all the properties of the object
515639
public String getRawWMIObjectOutput(String wmiClass) throws WMIException {
		String rawData;
		try {
			if (this.properties != null || this.filters != null) {
				rawData = getWMIStub().queryObject(wmiClass, this.properties, this.filters, this.namespace,
						this.computerName);
			} else {
				rawData = getWMIStub().listObject(wmiClass, this.namespace, this.computerName);
			}
		} catch (WMIException ex) {
			Logger.getLogger(WMI4Java.class.getName()).log(Level.SEVERE, GENERIC_ERROR_MSG, ex);
			throw new WMIException(ex);
		}
		return rawData;
	}
1339176
public function getElligibleProperties(RdfClass $class)
    {
        $properties = $this->getItemService()->getClazzProperties($class, new RdfClass(self::ITEM_CLASS_URI));
        return array_filter(
            $properties,
            function ($property) {
                if(in_array($property->getUri(), self::$excludedPropUris)){
                    return false;
                }
                $widget = $property->getWidget();
                return !is_null($widget) && in_array($widget->getUri(), self::$supportedWidgetUris);
            }
        );
    }
449832
public static Map<Object, Object> getAllGetterMethodWithCache(Class<?> pvClass, String pvFilter[]) {
		Map<Object, Object> lvGetterMap = classPropertiesCacheGetter.getClassPropertiesMapByClass(pvClass);
		if (lvGetterMap == null) {
			lvGetterMap = getAllGetterMethod(pvClass);
			Map<Object, Object> lvSetterMap = getAllSetterMethodWithCache(pvClass, pvFilter);
			lvGetterMap = getAllNotEqualsGetterAndSetterAndRemoveThisProperties (lvGetterMap, lvSetterMap);
			classPropertiesCacheGetter.addClassPropertiesMap(pvClass, lvGetterMap);
		}
		return lvGetterMap;
	}
1178993
static String getClassName(ClassSymbol c, boolean full) {
        if (full) {
            return c.getQualifiedName().toString();
        } else {
            String n = "";
            for ( ; c != null; c = c.owner.enclClass()) {
                n = c.name + (n.equals("") ? "" : ".") + n;
            }
            return n;
        }
    }
286318
@Override
    public Object[][] getAllData() {
        logger.entering();
        Object[][] objectArray;

        if ((null == resource.getCls()) && (null != resource.getXpathMap())) {
            Document doc = getDocument();
            Object[][][] multipleObjectDataProviders = new Object[resource.getXpathMap().size()][][];
            int i = 0;
            for (Entry<String, Class<?>> entry : resource.getXpathMap().entrySet()) {
                String xml = getFilteredXml(doc, entry.getKey());
                List<?> object = loadDataFromXml(xml, entry.getValue());
                Object[][] objectDataProvider = DataProviderHelper.convertToObjectArray(object);
                multipleObjectDataProviders[i++] = objectDataProvider;
            }
            objectArray = DataProviderHelper.getAllDataMultipleArgs(multipleObjectDataProviders);
        } else {
            List<?> objectList = loadDataFromXmlFile();
            objectArray = DataProviderHelper.convertToObjectArray(objectList);
        }

        // Passing no arguments to exiting() because implementation to print 2D array could be highly recursive.
        logger.exiting();
        return objectArray;
    }
14498
static private Class findClassFor(String s) throws ClassNotFoundException
	{ 
		int endClassIndex = s.indexOf('[');
		if (endClassIndex>=0) s = s.substring(0,endClassIndex);
		try {
			return Class.forName(s);
		} catch (ClassNotFoundException e) {
			return Class.forName("com.wcohen.ss."+s);
		}
	}
660190
public <T> List<T> getObjectsList(Class<T> objectClass,
			Collection<? extends NameValuePair> params) throws RedmineException {
		final EntityConfig<T> config = getConfig(objectClass);
		final List<T> result = new ArrayList<T>();

		final List<NameValuePair> newParams = new ArrayList<NameValuePair>(
				params);

		newParams.add(new BasicNameValuePair("limit", String
				.valueOf(objectsPerPage)));
		int offset = 0;

		int totalObjectsFoundOnServer;
		do {
			List<NameValuePair> paramsList = new ArrayList<NameValuePair>(
					newParams);
			paramsList.add(new BasicNameValuePair("offset", String
					.valueOf(offset)));

			final URI uri = getURIConfigurator().getObjectsURI(objectClass,
					paramsList);

			logger.debug(uri.toString());
			final HttpGet http = new HttpGet(uri);

			final String response = getCommunicator().sendRequest(http);
			logger.debug("received: " + response);

			final List<T> foundItems;
			try {
				final JSONObject responseObject = RedmineJSONParser
						.getResponse(response);
				foundItems = JsonInput.getListOrNull(responseObject,
						config.multiObjectName, config.parser);
				result.addAll(foundItems);

				/* Necessary for trackers */
				if (!responseObject.has(KEY_TOTAL_COUNT)) {
					break;
				}
				totalObjectsFoundOnServer = JsonInput.getInt(responseObject,
						KEY_TOTAL_COUNT);
			} catch (JSONException e) {
				throw new RedmineFormatException(e);
			}

			if (foundItems.size() == 0) {
				break;
			}

			offset += foundItems.size();
		} while (offset < totalObjectsFoundOnServer);

		return result;
	}
224177
public List<ORecordOperation> getRecordEntriesByClass(final String iClassName) {
    final List<ORecordOperation> result = new ArrayList<ORecordOperation>();

    if (iClassName == null || iClassName.length() == 0)
      // RETURN ALL THE RECORDS
      for (ORecordOperation entry : recordEntries.values()) {
        result.add(entry);
      }
    else
      // FILTER RECORDS BY CLASSNAME
      for (ORecordOperation entry : recordEntries.values()) {
        if (entry.getRecord() != null && entry.getRecord() instanceof ODocument
            && iClassName.equals(((ODocument) entry.getRecord()).getClassName()))
          result.add(entry);
      }

    return result;
  }
476621
def _get_classes_to_inspect(self):
        
        return tuple(filter(lambda c:
                      SerializableMixIn._get_version(c, require=False) or
                      (SerializableMixIn._get_serialize_fields(c) or
                       SerializableMixIn._get_interpolation_map(c)),
                      self.__class__.__mro__))
314244
static List<JmxData> query(ObjectName query) throws Exception {
    return query(ManagementFactory.getPlatformMBeanServer(), query);
  }
945005
@Override
	public String[] getPropertyStrings(Class<?> aClass, String key,
			String[] aDefault)
	{
		String property = getProperty(aClass, key,"");
		
		if("".equals(property))
			return aDefault;
		
		return Text.split(property);
	}
807810
public static String getSimpleName(Class<?> klass) {
      String simpleName = klass.getSimpleName();
      if (simpleName.isEmpty()) {
         String fullName = klass.getName();
         int index = fullName.lastIndexOf('.');
         simpleName = (index < 0) ? fullName : fullName.substring(index + 1);
      }
      return simpleName;
   }
1010641
public function getData() : \stdClass
    {
        $output = new \stdClass();

        $propertyNames = array_keys($this->defaultProperties);
        foreach ($propertyNames as $property) {
            $key = strtolower($property);

            if (array_key_exists($key, $this->data)) {
                $output->{$key} = $this->data[$key];
            } elseif ('parent' !== $key) {
                $output->{$key} = $this->defaultProperties[$property];
            }
        }

        // Don't want to normally do this, just if it exists in the data file
        // for our test runs
        if (array_key_exists('patternid', $this->data)) {
            $output->patternid = $this->data['patternid'];
        }

        return $output;
    }
672483
public static String getShortClassName(@SuppressWarnings("rawtypes") Class cls) {
		if (cls == null) {
			return "";
		}
		return getShortClassName(cls.getName());
	}
537659
def class_names op, deep_inheritance = false
    @options.flags = Openwsman::FLAG_ENUMERATION_OPTIMIZATION
    @options.max_elements = 999
    namespace = (op.is_a? Sfcc::Cim::ObjectPath) ? op.namespace : op
    classname = (op.is_a? Sfcc::Cim::ObjectPath) ? op.classname : nil
    case @product
    when :openwsman
      if @product_version < "2.2"
        STDERR.puts "ENUMERATE_CLASS_NAMES unsupported for #{@product_vendor} #{@product_version}, please upgrade"
        return []
      end
      method = Openwsman::CIM_ACTION_ENUMERATE_CLASS_NAMES
      uri = Openwsman::XML_NS_CIM_INTRINSIC
      @options.cim_namespace = namespace
      @options.add_selector("DeepInheritance", "True") if deep_inheritance
      result = @client.invoke( @options, uri, method )
    when :winrm
      # see https://github.com/kkaempf/openwsman/blob/master/bindings/ruby/tests/winenum.rb
      filter = Openwsman::Filter.new
      query = "select * from meta_class"
      query << " where __SuperClass is #{classname?classname:'null'}" unless deep_inheritance
      filter.wql query
      uri = "#{@prefix}#{namespace}/*"
      result = @client.enumerate( @options, filter, uri )
    else
      raise "Unsupported for WSMAN product #{@product}"
    end
    
    if _handle_fault @client, result
      return []
    end
    
    classes = []
    
    case @product
    when :openwsman
      # extract invoke result
      output = result.body[method]
      output.each do |c|
        classes << c.to_s
      end
    when :winrm
      # extract enumerate/pull result
      loop do
        output = result.Items
        output.each do |node|
          classes << node.name.to_s
        end if output
        context = result.context
        break unless context
        # get the next chunk
        result = @client.pull( @options, nil, uri, context)
        break if _handle_fault @client, result
      end
    end
    return classes
  end
332476
public static Map<Object, Object> getAllSetterMethodWithCache(Class<?> pvClass, String pvFilter[]) {
		Map<Object, Object> lvMap = classPropertiesCacheSetter.getClassPropertiesMapByClass(pvClass);
		if (lvMap == null) {
			lvMap = getAllSetterMethod(pvClass);
			classPropertiesCacheSetter.addClassPropertiesMap(pvClass, lvMap);
		}
		lvMap = Util.filterMapByKeys(lvMap, pvFilter);
		return lvMap;
	}
722932
private static Map<String, Method> getAllMethod(Class<?> clazz, Map<String, Method> methods) {
        if (clazz == null || clazz == Object.class) {
            return methods;
        }

        Arrays.stream(clazz.getDeclaredMethods()).forEach(method -> {
            String key = String.format("%s:%s", method.getName(),
                ByteCodeUtils.getMethodDesc(method));
            Method m = methods.get(key);
            if (m == null || (m.getDeclaringClass().isInterface()
                              && !method.getDeclaringClass().isInterface())) {
                methods.put(key, method);
            }
        });

        Arrays.stream(clazz.getInterfaces()).forEach(c -> getAllMethod(c, methods));

        return getAllMethod(clazz.getSuperclass(), methods);
    }