Return the body instance.
507651
def _get_body_instance(self):
        """"""
        exp_header = ExperimenterMultipartHeader
        simple_body = {MultipartType.OFPMP_DESC: Desc,
                       MultipartType.OFPMP_GROUP_FEATURES: GroupFeatures,
                       MultipartType.OFPMP_METER_FEATURES: MeterFeatures,
                       MultipartType.OFPMP_EXPERIMENTER: exp_header}

        array_of_bodies = {MultipartType.OFPMP_FLOW: FlowStats,
                           MultipartType.OFPMP_AGGREGATE: AggregateStatsReply,
                           MultipartType.OFPMP_TABLE: TableStats,
                           MultipartType.OFPMP_PORT_STATS: PortStats,
                           MultipartType.OFPMP_QUEUE: QueueStats,
                           MultipartType.OFPMP_GROUP: GroupStats,
                           MultipartType.OFPMP_GROUP_DESC: GroupDescStats,
                           MultipartType.OFPMP_METER: MeterStats,
                           MultipartType.OFPMP_METER_CONFIG: MeterConfig,
                           MultipartType.OFPMP_TABLE_FEATURES: TableFeatures,
                           MultipartType.OFPMP_PORT_DESC: Port}

        if isinstance(self.multipart_type, (int, UBInt16)):
            self.multipart_type = self.multipart_type.enum_ref(
                self.multipart_type.value)

        pyof_class = simple_body.get(self.multipart_type, None)
        if pyof_class:
            return pyof_class()

        array_of_class = array_of_bodies.get(self.multipart_type, None)
        if array_of_class:
            return FixedTypeList(pyof_class=array_of_class)

        return BinaryData(b'')
710565
public String getBody() {
        JsonNode body=getBodyJson();
        if(body!=null) {
            return body.toString();
        } else {
            return null;
        }
    }
356530
def body(self):
        
        body = self.get_parameters_by_location(['body'])
        return self.root.schemas.get(body[0].type) if body else None
1335882
def get(self, model, **spec):
        

        handles = self.__find_handles(model, **spec)
        if len(handles) > 1:
            raise MultipleObjectsReturned()
        if not handles:
            raise ObjectDoesNotExist()
        return self.get_instance(model, handles[0])
614364
def body(self):
        
        body, _, is_markdown = self._entry_content
        return TrueCallableProxy(
            self._get_markup,
            body,
            is_markdown) if body else CallableProxy(None)
495932
def func(self, name: str):
        """"""
        for f in self.body:
            if (hasattr(f, '_ctype')
                    and isinstance(f._ctype, FuncType)
                    and f._name == name):
                return f
867921
def p_Body(p):
    '''
    
    '''
    if not isinstance(p[1], Body):
        p[0] = Body(None, p[1])
    else:
        p[0] = Body(p[1], p[2])
534757
public BufferResult getBody() {
		BufferResult b = body;
		if(b == null) return EmptyResult.getInstance();
		return b;
	}
1088473
def build_body(self):
        '''
        
        '''
        _increase_indent()
        body_array = [x.build() for x in self.iterable]

        nl = '\n' if self.append_extra_newline else ''

        if len(self.iterable) >= 1:
            body = self.join_body_on.join(body_array) + nl
        else:
            body = ''

        _decrease_indent()
        return body
582327
def get_body(self):
        

        raw_body = yield get_arg(self, 2)
        if not self.serializer:
            raise tornado.gen.Return(raw_body)
        else:
            body = self.serializer.deserialize_body(raw_body)
            raise tornado.gen.Return(body)
1060182
public function getBody()
    {
        return $this->body instanceof Swift_OutputByteStream ? $this->readStream($this->body) : $this->body;
    }
1202140
def body(self):
        """"""
        if self._body is None:
            raw_body = self._raw_body
            if self._body_writer is None:
                self._body = raw_body() if callable(raw_body) else raw_body
            else:
                self._body = self._body_writer(raw_body)

        return self._body
1279255
public function getBody(): Parameters
	{
		if($this->parsedBody === null)
		{
			$this->parsedBody = new Body($this->getRawBody(), $this->getContentType());
		}

		return $this->parsedBody;
	}
665226
def body(body)
      indented = indent
      indented.puts('body:')
      body.each do |member|
        member.pretty_dump(indented.indent)
      end
      self
    end
85604
public function body()
    {
        if (!$this->bodyRendered) {
            $this->body = $this->renderBody();
            $this->bodyRendered = true;
        }
        return $this->body;
    }
636226
public AbstractBody getBody() throws InterruptedException, BOSHException {
        if (toThrow != null) {
            throw(toThrow);
        }
        lock.lock();
        try {
            if (!sent) {
                awaitResponse();
            }
        } finally {
            lock.unlock();
        }
        return body;
    }
980833
public function getBody()
    {
        if (!($this->body instanceof StreamInterface)) {
            $this->body = new Stream(Stream::createResourceTemp());
        }

        return $this->body;
    }