// GetContents 指定したジャンルの記事を取得する.
978203
func (t *TrendService) GetContents(req TrendContentsRequest) (*TrendContentsResponse, error) {

	v := url.Values{}
	if req.GenreID == nil {
		// ジャンル指定は必須
		return nil, errors.New("genreId has not set")
	}
	v.Set("genreId", strconv.Itoa(*req.GenreID))

	if req.Lang != nil {
		v.Set("lang", *req.Lang)
	}
	if req.StartNo != nil {
		v.Set("s", strconv.Itoa(*req.StartNo))
	}
	if req.Num != nil {
		v.Set("n", strconv.Itoa(*req.Num))
	}

	var trendRes TrendContentsResponse
	res, err := t.client.get(t.ctx, TrendContentsURL, v, &trendRes)
	if err != nil {
		return nil, err
	}

	defer res.Body.Close()

	return &trendRes, nil
}
1352908
func (r *Response) NoContent() *Response {
	if r.chain.failed() {
		return r
	}

	contentType := r.resp.Header.Get("Content-Type")

	r.checkEqual("\"Content-Type\" header", "", contentType)
	r.checkEqual("body", "", string(r.content))

	return r
}
109247
func (u *volumeUtil) DeleteContents(fullPath string) error {
	dir, err := os.Open(fullPath)
	if err != nil {
		return err
	}
	defer dir.Close()

	files, err := dir.Readdirnames(-1)
	if err != nil {
		return err
	}
	errList := []error{}
	for _, file := range files {
		err = os.RemoveAll(filepath.Join(fullPath, file))
		if err != nil {
			errList = append(errList, err)
		}
	}

	return utilerrors.NewAggregate(errList)
}
1217722
func (g *GistFile) GetContent() string {
	if g == nil || g.Content == nil {
		return ""
	}
	return *g.Content
}
91917
func (extr *ContentExtractor) GetMetaContents(document *goquery.Document, metaNames *set.Set) map[string]string {
	contents := make(map[string]string)
	counter := metaNames.Size()
	document.Find("meta").EachWithBreak(func(i int, s *goquery.Selection) bool {
		attr, exists := s.Attr("name")
		if exists && metaNames.Has(attr) {
			content, _ := s.Attr("content")
			contents[attr] = content
			counter--
			if counter < 0 {
				return false
			}
		}
		return true
	})
	return contents
}
1304292
func (h *Handler) GetContent(feed *Feed) (storage.Address, []byte, error) {
	if feed == nil {
		return nil, nil, NewError(ErrInvalidValue, "feed is nil")
	}
	feedUpdate := h.get(feed)
	if feedUpdate == nil {
		return nil, nil, NewError(ErrNotFound, "feed update not cached")
	}
	return feedUpdate.lastKey, feedUpdate.data, nil
}
73850
func (b Binary) GetContent() (string, error) {
	// Check for base64 content (KDBX 3.1), if it fail try with KDBX 4
	decoded := make([]byte, base64.StdEncoding.DecodedLen(len(b.Content)))
	_, err := base64.StdEncoding.Decode(decoded, b.Content)
	if err != nil {
		// KDBX 4 doesn't encode it
		decoded = b.Content[:]
	}

	if b.Compressed {
		reader, err := gzip.NewReader(bytes.NewReader(decoded))
		if err != nil {
			return "", err
		}
		defer reader.Close()
		bts, err := ioutil.ReadAll(reader)
		if err != nil && err != io.ErrUnexpectedEOF {
			return "", err
		}
		return string(bts), nil
	}
	return string(decoded), nil
}
504986
func (obj *Variable) GetContent(ctx context.Context) (*AlfaNumString, error) {
	result := &struct {
		Content *AlfaNumString	`json:"qContent"`
	} {}
	err := obj.rpc(ctx, "GetContent", result)
	return result.Content, err 
}
612794
func (obj *Variable) GetContentRaw(ctx context.Context) (json.RawMessage, error) {
	result := &struct {
		Content json.RawMessage	`json:"qContent"`
	} {}
	err := obj.rpc(ctx, "GetContent", result)
	return result.Content, err 
}
797531
func (s *ReleaseServer) GetReleaseContent(c ctx.Context, req *services.GetReleaseContentRequest) (*services.GetReleaseContentResponse, error) {
	if err := validateReleaseName(req.Name); err != nil {
		s.Log("releaseContent: Release name is invalid: %s", req.Name)
		return nil, err
	}

	if req.Version <= 0 {
		rel, err := s.env.Releases.Last(req.Name)
		return &services.GetReleaseContentResponse{Release: rel}, err
	}

	rel, err := s.env.Releases.Get(req.Name, req.Version)
	return &services.GetReleaseContentResponse{Release: rel}, err
}
775961
func (client *Client) GetMessageContent(messageID string) *GetMessageContentCall {
	return &GetMessageContentCall{
		c:         client,
		messageID: messageID,
	}
}
624857
func serviceContents(e interface{}) string {
	vars := getEnvVars(e)
	if len(vars) == 0 {
		return ""
	}

	out := "[Service]\n"
	for _, v := range vars {
		out += fmt.Sprintf("Environment=\"%s\"\n", v)
	}
	return out
}
1216378
func (f *File) ReadContent() error {
	if len(f.Content) == 0 {
		content, err := ioutil.ReadFile(path.Join(f.Path, f.FileName))
		if err != nil {
			return err
		}
		f.Content = content
	}
	return nil
}
66701
func (surface *RecordingSurface) GetExtents(extents *Rectangle) bool {
	ret := C.cairo_recording_surface_get_extents(surface.Ptr, (*C.cairo_rectangle_t)(unsafe.Pointer(extents))) != 0
	if err := surface.status(); err != nil {
		panic(err)
	}
	return ret
}
485917
func NoContent(w http.ResponseWriter) {
	// No custom handler since there's no custom behavior.
	w.Header().Del("Content-Type")
	w.WriteHeader(http.StatusNoContent)
}
519077
func readFileContents(workingDirectory string, fileName string) ([]byte, error) {

	filePath := filepath.Join(workingDirectory, fileName)

	if fileName == "" {
		return nil, fmt.Errorf("File name cannot be nil: %s", filePath)
	}

	// Read the file
	fileContentsArray, err := ioutil.ReadFile(filePath)
	if err != nil {
		return nil,
			fmt.Errorf("Could not read file %s (Error: %s)",
				filePath, err.Error())
	}

	return fileContentsArray, nil
}
1239506
func (d *driver) GetContent(ctx context.Context, path string) ([]byte, error) {
	d.mutex.RLock()
	defer d.mutex.RUnlock()

	rc, err := d.reader(ctx, path, 0)
	if err != nil {
		return nil, err
	}
	defer rc.Close()

	return ioutil.ReadAll(rc)
}