Do the rendering.
421451
def render_template(template, flow_expression, workitem)

      template = (File.read(template) rescue nil) if is_a_file?(template)

      return render_default_template(workitem) unless template

      template = template.to_s
      workitem = workitem.to_h if workitem.respond_to?(:to_h)

      @context.dollar_sub.s(template, flow_expression, workitem)
    end
391482
public void render() {
		if (list == -1) {
			throw new RuntimeException("Attempt to render cached operations that have been destroyed");
		}
		
		SlickCallable.enterSafeBlock();
		GL.glCallList(list);
		SlickCallable.leaveSafeBlock();
	}
494363
public function render()
    {
        $text = $this->generator->generate();
        $answer = $this->generator->getAnswer();

        $this->storage->set($answer);
        $this->imageGenerator->render($text);
    }
317908
def render(self, display):
        """"""

        # the bar
        bar_rect = pygame.Rect(0, 0, self.width, self.height // 3)
        bar_rect.center = self.center
        display.fill(self.bg_color, bar_rect)

        # the cursor
        circle(display, (self.value_px, self.centery), self.height // 2, self.color)

        # the value
        if self.show_val:
            self.text_val.render(display)
432877
def render(self, view, context=None):
        """"""
        return self.runtime.render(self, view, context)
296934
def render(self, content = None, **settings):
        
        (content, settings) = self.get_setup(content, **settings)
        return self._render(content, **settings)
1286005
def render(self, surf):
        """"""
        if not self.flags & self.NO_SHADOW:
            circle(surf, self.center + self._bg_delta, self.width / 2, LIGHT_GREY)
        circle(surf, self.center + self._front_delta, self.width / 2, self._get_color())

        self.text.center = self.center + self._front_delta
        self.text.render(surf)
112317
public function render()
	{
		$this->template->steps = $this->getSteps();
		$this->template->paginator = $this->getPaginator();
		$this->template->setFile($this->templateFile)->render();
	}
1111247
public function run()
	{
		$clip=ob_get_clean();
		if($this->renderClip)
			echo $clip;
		$this->getController()->getClips()->add($this->getId(),$clip);
	}
1370559
protected function render ()
  {
    if ($this->view) {
      // The view model is sent to render() because the view may not be a Matisse template, in which case the model must
      // be set explicitly.
      echo $this->view->render ($this->getViewModel ());
    }
    elseif ($this->shadowDOM)
      $this->shadowDOM->run ();
    // Otherwise, do NOT render the component's content
  }
759242
def render(*args, &block)
      captured = helpers.capture do
        helpers.concat(helpers.render(*args, &block))
        helpers.output_buffer.to_s
      end
      rawtext(captured)
    end
991850
def render(self, surf):
        """"""
        pos, size = self.topleft, self.size

        if not self.flags & self.NO_SHADOW:
            if self.flags & self.NO_ROUNDING:
                pygame.draw.rect(surf, LIGHT_GREY, (pos + self._bg_delta, size))
            else:
                roundrect(surf, (pos + self._bg_delta, size), LIGHT_GREY + (100,), 5)

        if self.flags & self.NO_ROUNDING:
            pygame.draw.rect(surf, self._get_color(), (pos + self._front_delta, size))
        else:
            roundrect(surf, (pos + self._front_delta, size), self._get_color(), 5)

        self.text.center = self.center + self._front_delta
        self.text.render(surf)
104838
protected function render()
    {
        $this->display('* Rendering documents');
        foreach ($this->documents as $file => &$document) {
            $this->display(' -> Rendering '.$file.'...');
            $target = $this->getTargetOf($file);

            $directory = dirname($target);
            if (!is_dir($directory)) {
                mkdir($directory, 0755, true);
            }

            file_put_contents($target, $document->renderDocument());
        }
    }
311276
def render(self, *args, **kwargs):
        """"""
        # args kwargs API provided for last minute content injection
        # self._reverse_mro_func('pre_render')
        pretty = kwargs.pop("pretty", False)
        if pretty and self._stable != "pretty":
            self._stable = False

        for arg in args:
            self._stable = False
            if isinstance(arg, dict):
                self.inject(arg)
        if kwargs:
            self._stable = False
            self.inject(kwargs)

        # If the tag or his contents are not changed and we already have rendered it
        # with the same attrs we skip all the work
        if self._stable and self._render:
            return self._render

        pretty_pre = pretty_inner = ""
        if pretty:
            pretty_pre = "\n" + ("\t" * self._depth) if pretty else ""
            pretty_inner = "\n" + ("\t" * self._depth) if len(self.childs) > 1 else ""
        inner = self.render_childs(pretty) if not self._void else ""

        # We declare the tag is stable and have an official render:
        tag_data = (
            pretty_pre,
            self._get__tag(),
            self.render_attrs(),
            inner,
            pretty_inner,
            self._get__tag()
        )[: 6 - [0, 3][self._void]]
        self._render = self._template % tag_data
        self._stable = "pretty" if pretty else True
        return self._render
1059675
public function render()
    {
        if (empty($this->_rows) || empty($this->_columns)) {
            return;
        }

        foreach ($this->_rows as $row) {
            $this->renderRowCells($row);
        }
    }
1336486
public void render (Component host, RadialMenu menu, Graphics2D gfx, int x, int y)
    {
        paint(gfx, x, y, menu);
    }
1018503
protected function render ()
  {
    $this->context->getAssetsService ()->beginAssetsContext ($this->props->prepend);
    $this->runChildren ();
    $this->context->getAssetsService ()->endAssetsContext ();
  }