001
002package com.commercetools.history.models.change_history;
003
004import java.time.*;
005import java.util.*;
006import java.util.function.Function;
007import java.util.stream.Collectors;
008
009import javax.annotation.Nullable;
010import javax.validation.Valid;
011import javax.validation.constraints.NotNull;
012
013import com.fasterxml.jackson.annotation.*;
014import com.fasterxml.jackson.databind.annotation.*;
015
016import io.vrap.rmf.base.client.utils.Generated;
017
018/**
019 *  <p>PagedQueryResult with <code>results</code> containing an array of Record.</p>
020 *
021 * <hr>
022 * Example to create an instance using the builder pattern
023 * <div class=code-example>
024 * <pre><code class='java'>
025 *     RecordPagedQueryResponse recordPagedQueryResponse = RecordPagedQueryResponse.builder()
026 *             .limit(1)
027 *             .count(1)
028 *             .total(1)
029 *             .offset(1)
030 *             .plusResults(resultsBuilder -> resultsBuilder)
031 *             .build()
032 * </code></pre>
033 * </div>
034 */
035@Generated(value = "io.vrap.rmf.codegen.rendering.CoreCodeGenerator", comments = "https://github.com/commercetools/rmf-codegen")
036@JsonDeserialize(as = RecordPagedQueryResponseImpl.class)
037public interface RecordPagedQueryResponse {
038
039    /**
040     *  <p>Number of results requested.</p>
041     * @return limit
042     */
043    @NotNull
044    @JsonProperty("limit")
045    public Integer getLimit();
046
047    /**
048     *  <p>Actual number of results returned.</p>
049     * @return count
050     */
051    @NotNull
052    @JsonProperty("count")
053    public Integer getCount();
054
055    /**
056     *  <p>Total number of results matching the query. This number is an estimation and not strongly consistent.</p>
057     * @return total
058     */
059    @NotNull
060    @JsonProperty("total")
061    public Integer getTotal();
062
063    /**
064     *  <p>Number of elements skipped.</p>
065     * @return offset
066     */
067    @NotNull
068    @JsonProperty("offset")
069    public Integer getOffset();
070
071    /**
072     *  <p>Records matching the query.</p>
073     * @return results
074     */
075    @NotNull
076    @Valid
077    @JsonProperty("results")
078    public List<Record> getResults();
079
080    /**
081     *  <p>Number of results requested.</p>
082     * @param limit value to be set
083     */
084
085    public void setLimit(final Integer limit);
086
087    /**
088     *  <p>Actual number of results returned.</p>
089     * @param count value to be set
090     */
091
092    public void setCount(final Integer count);
093
094    /**
095     *  <p>Total number of results matching the query. This number is an estimation and not strongly consistent.</p>
096     * @param total value to be set
097     */
098
099    public void setTotal(final Integer total);
100
101    /**
102     *  <p>Number of elements skipped.</p>
103     * @param offset value to be set
104     */
105
106    public void setOffset(final Integer offset);
107
108    /**
109     *  <p>Records matching the query.</p>
110     * @param results values to be set
111     */
112
113    @JsonIgnore
114    public void setResults(final Record... results);
115
116    /**
117     *  <p>Records matching the query.</p>
118     * @param results values to be set
119     */
120
121    public void setResults(final List<Record> results);
122
123    /**
124     * factory method
125     * @return instance of RecordPagedQueryResponse
126     */
127    public static RecordPagedQueryResponse of() {
128        return new RecordPagedQueryResponseImpl();
129    }
130
131    /**
132     * factory method to create a shallow copy RecordPagedQueryResponse
133     * @param template instance to be copied
134     * @return copy instance
135     */
136    public static RecordPagedQueryResponse of(final RecordPagedQueryResponse template) {
137        RecordPagedQueryResponseImpl instance = new RecordPagedQueryResponseImpl();
138        instance.setLimit(template.getLimit());
139        instance.setCount(template.getCount());
140        instance.setTotal(template.getTotal());
141        instance.setOffset(template.getOffset());
142        instance.setResults(template.getResults());
143        return instance;
144    }
145
146    /**
147     * factory method to create a deep copy of RecordPagedQueryResponse
148     * @param template instance to be copied
149     * @return copy instance
150     */
151    @Nullable
152    public static RecordPagedQueryResponse deepCopy(@Nullable final RecordPagedQueryResponse template) {
153        if (template == null) {
154            return null;
155        }
156        RecordPagedQueryResponseImpl instance = new RecordPagedQueryResponseImpl();
157        instance.setLimit(template.getLimit());
158        instance.setCount(template.getCount());
159        instance.setTotal(template.getTotal());
160        instance.setOffset(template.getOffset());
161        instance.setResults(Optional.ofNullable(template.getResults())
162                .map(t -> t.stream()
163                        .map(com.commercetools.history.models.change_history.Record::deepCopy)
164                        .collect(Collectors.toList()))
165                .orElse(null));
166        return instance;
167    }
168
169    /**
170     * builder factory method for RecordPagedQueryResponse
171     * @return builder
172     */
173    public static RecordPagedQueryResponseBuilder builder() {
174        return RecordPagedQueryResponseBuilder.of();
175    }
176
177    /**
178     * create builder for RecordPagedQueryResponse instance
179     * @param template instance with prefilled values for the builder
180     * @return builder
181     */
182    public static RecordPagedQueryResponseBuilder builder(final RecordPagedQueryResponse template) {
183        return RecordPagedQueryResponseBuilder.of(template);
184    }
185
186    /**
187     * accessor map function
188     * @param <T> mapped type
189     * @param helper function to map the object
190     * @return mapped value
191     */
192    default <T> T withRecordPagedQueryResponse(Function<RecordPagedQueryResponse, T> helper) {
193        return helper.apply(this);
194    }
195
196    /**
197     * gives a TypeReference for usage with Jackson DataBind
198     * @return TypeReference
199     */
200    public static com.fasterxml.jackson.core.type.TypeReference<RecordPagedQueryResponse> typeReference() {
201        return new com.fasterxml.jackson.core.type.TypeReference<RecordPagedQueryResponse>() {
202            @Override
203            public String toString() {
204                return "TypeReference<RecordPagedQueryResponse>";
205            }
206        };
207    }
208}