Get transform property of object, by object type
 @param object [Symbol] type of object: :image, :chart, :table, :shape
 @return [OOXMLDocumentObject] needed object
424041
def transform_of_object(object)
      case object
      when :image
        elements.find { |e| e.is_a? Picture }.properties.transform
      when :chart
        elements.find { |e| e.is_a? GraphicFrame }.transform
      when :table
        elements.find { |e| e.is_a? GraphicFrame }.transform
      when :shape
        elements.find { |e| !e.shape_properties.preset.nil? }.shape_properties.transform
      else
        raise "Dont know this type object - #{object}"
      end
    end
690027
function(element, options)
    {
        // Make sure the transform property is an object
        if(typeof element.transform != "object")
        {
            element.transform = {};
        }

        // If we have an object of options
        if(typeof options[0] == "object")
        {
            // Loop through object properties and save their values
            var keys = Object.keys(options[0]);

            keys.forEach(function(property)
            {
                element.transform[property] = options[0][property];
            });
        }
        
        // Otherwise, loop through all of the options to find values
        else
        {
            var property = options[0];
            var args = [];

            for(var i = 1, l = options.length; i < l; i++)
            {
                args.push(options[i]);
            }

            element.transform[property] = args;
        }
    }
261017
function transformType (type) {
  if (Array.isArray(type)) {
    return transformArray(type)
  }

  if (typeof type === 'object') {
    return transformObject(type)
  }

  if (
    typeof type === 'function' &&
    (!type.prototype || type.name === '')
  ) {
    return type
  }

  return findType(type)
}
433728
public static Object getPropertyValue(StructuralProperty property, Object object) {
        Field field = property.getJavaField();
        field.setAccessible(true);
        try {
            return field.get(object);
        } catch (IllegalAccessException e) {
            throw new ODataSystemException("Cannot read property: " + property + " of object: " + object, e);
        }
    }
921163
function toObjectExpression(object) {
    const properties = Object.keys(object).map(key => {
      return t.objectProperty(t.identifier(key), object[key]);
    });

    return t.objectExpression(properties);
  }
199042
def house(self):
        
        house = self.chart.houses.getObjectHouse(self.obj)
        return house
980942
public Object getProperty(Object object, String property) {
        return delegate.getProperty(object, property);
    }
162488
function getCustomProperties(object) {
  var result = {};
  for (var key in object) {
    if (/^x-/.test(key)) {
      result[key] = object[key];
    }
  }
  return result;
}
1268014
def get_chart(self, id, **kwargs):
        "
        resp = self._get_object_by_name(self._CHART_ENDPOINT_SUFFIX, id,
                                        **kwargs)
        return resp
569893
def object_to_pdf(object)
      if object.nil?
        return 'null'
      elsif object.is_a?(String)
        return format_string_to_pdf object
      elsif object.is_a?(Symbol)
        return format_name_to_pdf object
      elsif object.is_a?(Array)
        return format_array_to_pdf object
      elsif object.is_a?(Integer) || object.is_a?(TrueClass) || object.is_a?(FalseClass)
        return object.to_s
      elsif object.is_a?(Numeric) # Float or other non-integer
        return sprintf('%f', object)
      elsif object.is_a?(Hash)
        return format_hash_to_pdf object
      else
        return ''
      end
    end
854601
public function transform($object)
    {
        if (is_object($object) && $object instanceof RestfulModel) {
            $transformed = $this->transformRestfulModel($object);
        } elseif (is_object($object) && $object instanceof \stdClass) {
            $transformed = $this->transformStdClass($object);
        } else {
            throw new \Exception('Unexpected object type encountered in transformer');
        }

        return $transformed;
    }
500071
function transformObject (type) {
  const transformed = {}

  for (let key in type) {
    transformed[key] = transformType(type[key])
  }

  return transformed
}
1281960
public Matrix4f getTransform(Item item, TransformType transformType)
	{
		switch (transformType)
		{
			case THIRD_PERSON_LEFT_HAND:
				return thirdPersonLeftHand;
			case THIRD_PERSON_RIGHT_HAND:
				return thirdPersonRightHand;
			case FIRST_PERSON_LEFT_HAND:
				return firstPersonLeftHand;
			case FIRST_PERSON_RIGHT_HAND:
				return firstPersonRightHand;
			case HEAD:
				return head;
			case GUI:
				return gui;
			case GROUND:
				return ground;
			case FIXED:
				return fixed;
			default:
				return null;
		}
	}
330072
public function transform($object)
    {
        if (($collection = $this->normalize($object)) instanceof Collection) {
            return $this->transformCollection($collection);
        }

        // If there are relations setup, transform it along with the object.
        if ($this->relatedCount) {
            return $this->transformWithRelated($object);
        }

        // If another transformation method was requested, use that instead.
        if (is_callable($this->transformationMethod)) {
            return $this->getAlternateTransformation($object);
        }

        return $this->getTransformation($object);
    }
1319092
function getObjectSchema(object) {
  var outputObject = {};

  if (isObjectObject(object)) {
    Object.keys(object).forEach(function(key) {
      outputObject[key] = isObjectObject(object[key]) ? getObjectSchema(object[key]) : '';
    });
  }

  return outputObject;
}
558825
function(object) {
       var proj = object.layer.projection.toString();
       var crs = {};
       if (proj.match(/epsg:/i)) {
           var code = parseInt(proj.substring(proj.indexOf(":") + 1));
           if (code == 4326) {
               crs = {
                   "type": "name",
                   "properties": {
                       "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
                   }
               };
           } else {    
               crs = {
                   "type": "name",
                   "properties": {
                       "name": "EPSG:" + code
                   }
               };
           }    
       }
       return crs;
    }
686819
def get_html(self, chart_obj=None, slug=None):
        
        if chart_obj is None:
            if self.chart_obj is None:
                self.err(
                    "No chart object registered, please provide "
                    "one in parameters"
                )
                return
            chart_obj = self.chart_obj
        try:
            if self.engine == "bokeh":
                html = self._get_bokeh_html(chart_obj)
                if html is None:
                    self.err("No html returned for " + str(chart_obj))
                return html
            elif self.engine == "altair":
                html = self._get_altair_html_(chart_obj, slug)
                if html is None:
                    self.err("No html returned for " + str(chart_obj))
                return html
            else:
                self.err("Chart engine " + self.engine + " unknown")
                return
        except Exception as e:
            self.err(e, "Can not get html from chart object")