Renders the show view for the field value report, given by a compound key.
 The compound key is comprised by the field value report's field
 (represented by the route's id param) and the provider's id.
346027
def show
      @field_value_report = Krikri::FieldValueReport.find(params[:id], 
                                                          params[:provider_id])

      respond_to do |format|
        format.csv
      end
    end
1047412
def display_for_value(value, request=None):
    
    from is_core.utils.compatibility import admin_display_for_value

    if request and isinstance(value, Model):
        return render_model_object_with_link(request, value)
    else:
        return (
            (value and ugettext('Yes') or ugettext('No')) if isinstance(value, bool) else admin_display_for_value(value)
        )
1107093
public function renderUntil($field_name, $showFormEnd = true, $showFields = true)
    {
        $fields = $this->getUnrenderedFields();

        $i = 1;
        foreach ($fields as $key => $value) {
            if ($value->getRealName() == $field_name) {
                break;
            }
            $i++;
        }

        $fields = array_slice($fields, 0, $i, true);

        return $this->render([], $fields, false, $showFields, $showFormEnd);
    }
655745
public function modelRender()
    {
        if ($this->model instanceof \atk4\data\Model) {
            if ($this->controller instanceof Controller_ADView) {
                return;
            }
            $data = $this->model->persistence->typecastSaveRow($this->model, $this->model->get());
        } else {
            $data = $this->model->get();
        }

        $this->template->set($data);
    }
807950
public function renderSearchField()
    {
        if ($this->attributeKey !== null) {
            $type = $this->attributeKey->getAttributeType();
            $cnt = $type->getController();
            $cnt->setRequestArray($this->data);
            $cnt->setAttributeKey($this->attributeKey);
            $view = new View($this->attributeKey);
            $view->controller = $cnt;

            return $view->render(new BasicSearchContext());
        }
    }
40296
function renderParam(key, valueDict) {
    var paramDiv = $('<div class="status-param">');

    var nameDiv = $('<span class="status-param-name">');
    nameDiv.text(key + ':');
    paramDiv.append(nameDiv);

    if (valueDict.type == 'slot' && STATUS_MAP.slots) {
      paramDiv.append(renderSlot(valueDict.slotKey));
    } else {
      var valueDiv = $('<span class="status-param-value">');
      renderCollapsableValue(valueDict.value, valueDiv);
      paramDiv.append(valueDiv);
    }

    return paramDiv;
  }
222690
public function render()
	{
		if ($this->getDisplayField() === null) {
			throw new \InvalidArgumentException(sprintf('Please provide a display field for the `%s` relation.', $this->getName()));
		}

		switch ($this->getContext()) {
			case BaseField::CONTEXT_LIST:
				$baseModel    = $this->getAdmin()->getModel();
				$baseModel    = new $baseModel;

				$relatedModel = $baseModel->{$this->getName()}()->getRelated();
				$primaryKey   = $relatedModel->getKeyName();

				$values = [];
				foreach ($this->getValue() as $item) {
					$values[$item->{$primaryKey}] = $item->{$this->getDisplayField()};
				}

				return implode(', ', $values);

				break;
			case BaseField::CONTEXT_FORM:
				$baseModel  = $this->getAdmin()->getModel();
				$baseModel  = new $baseModel;
				$primaryKey = $baseModel->getKeyName();

				$relatedModel = $baseModel->{$this->getName()}()->getRelated();

				$items = [];
				foreach ($relatedModel::all() as $item) {
					$items[$item->{$primaryKey}] = $item->{$this->getDisplayField()};
				}

				$id = $this->getAdmin()->getFormBuilder()->getIdentifier();
				$values = [];

				if ($id !== null) {
					foreach ($baseModel::find($id)->{$relatedModel->getTable()} as $item) {
						$values[$item->{$primaryKey}] = $item->{$primaryKey};
					}
				}

				return View::make('krafthaus/bauhaus::models.fields._belongs_to_many')
					->with('field',  $this)
					->with('items',  $items)
					->with('values', $values);
		}
	}
65679
def field(key, value)
      field = "<<"
      field << "/T" + "(#{key})"
      field << "/V" + (Array === value ? "[#{value.map{ |v|"(#{quote(v)})" }.join}]" : "(#{quote(value)})")
      field << ">>\n"
      field
    end
1031499
def render(view_options=configuration)
      logger.debug "rendering"
      result = ""
      if template
        logger.debug "rendering with template : #{template}"
        view = AppView.new(items, view_options)
        view.template = template
        result = view.render
      else
        items.each_with_index do |item, index|
          result += "\n" unless index == 0
          result += item.name.green + ":\n"
          if item.respond_to?(:attributes)
            attributes = item.attributes.deep_clone
            result += attributes.recursively_stringify_keys!.to_conf.gsub(/\s+$/, '') # strip trailing whitespace from YAML
            result += "\n"
          end
        end
      end
      result
    end
1257601
def render_field(field, **kwargs):
    
    renderer_cls = get_field_renderer(**kwargs)
    return renderer_cls(field, **kwargs).render()
587
protected void view(Map<String, Object> values){
        for(String key:values.keySet() ){
            view(key, values.get(key));
        }
    }
1115409
def _render_relationships(self, resource):
        """"""
        relationships = {}
        related_models = resource.__mapper__.relationships.keys()
        primary_key_val = getattr(resource, self.primary_key)
        if self.dasherize:
            mapped_relationships = {
                x: dasherize(underscore(x)) for x in related_models}
        else:
            mapped_relationships = {x: x for x in related_models}

        for model in related_models:
            relationships[mapped_relationships[model]] = {
                'links': {
                    'self': '/{}/{}/relationships/{}'.format(
                        resource.__tablename__,
                        primary_key_val,
                        mapped_relationships[model]),
                    'related': '/{}/{}/{}'.format(
                        resource.__tablename__,
                        primary_key_val,
                        mapped_relationships[model])
                }
            }

        return relationships
633758
def render_post_field(post_field, key_parent = 'fields')
      # define key
      key = "#{key_parent}[#{post_field.id}]"
      # render correct field
      case post_field.typology
      when 'text'
        render_post_field_text(post_field, key)
      when 'textarea'
        render_post_field_textarea(post_field, key)
      when 'datetime'
        render_post_field_datetime(post_field, key)
      when 'editor'
        render_post_field_editor(post_field, key)
      when 'geolocalization'
        render_post_field_geolocalization(post_field, key)
      when 'image'
        render_post_field_image(post_field, key)
      when 'gallery'
        render_post_field_gallery(post_field, key)
      when 'youtube'
        render_post_field_youtube(post_field, key)
      when 'composed'
        render_post_field_composed(post_field, key)
      when 'relay'
        render_post_field_relay(post_field, key)
      end
    end
429432
function renderOReillyField() {
		$this->renderField(
			[
				'id' => 'oreilly',
				'name' => $this->getSlug(),
				'option' => 'oreilly',
				'value' => ( isset( $this->options['oreilly'] ) ) ? $this->options['oreilly'] : '',
				'type' => 'url',
				'class' => 'regular-text code',
			]
		);
	}
403474
@Override
    public String display(Type type, Object value, Map parameters)
    {
        return display(type, value, parameters, "view");
    }
1273848
def inq_compound_field(self, name, index):
        
        typename = create_string_buffer(name)
        index = c_int(index + 1)
        fieldname = create_string_buffer(MAXSTRLEN)
        fieldtype = create_string_buffer(MAXSTRLEN)
        rank = c_int()
        arraytype = ndpointer(dtype='int32',
                              ndim=1,
                              shape=(MAXDIMS, ),
                              flags='F')
        shape = np.empty((MAXDIMS, ), dtype='int32', order='F')
        self.library.inq_compound_field.argtypes = [c_char_p,
                                                    POINTER(c_int),
                                                    c_char_p,
                                                    c_char_p,
                                                    POINTER(c_int),
                                                    arraytype]
        self.library.inq_compound_field.restype = None
        self.library.inq_compound_field(typename,
                                        byref(index),
                                        fieldname,
                                        fieldtype,
                                        byref(rank),
                                        shape)
        return (fieldname.value,
                fieldtype.value,
                rank.value,
                tuple(shape[:rank.value]))
656465
def show(self):
        
        bytecode._PrintSubBanner("Field Information")
        bytecode._PrintDefault("%s->%s %s [access_flags=%s]\n" % (
            self.get_class_name(), self.get_name(), self.get_descriptor(),
            self.get_access_flags_string()))

        init_value = self.get_init_value()
        if init_value != None:
            bytecode._PrintDefault("\tinit value: %s\n" %
                                   str(init_value.get_value()))

        self.show_xref(self.CM.get_vmanalysis().get_field_analysis(self))