Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto;
 
 
 import java.util.List;
 
 import static com.facebook.presto.RowPageBuilder.rowPageBuilder;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class RowPagesBuilder
 {
     public static RowPagesBuilder rowPagesBuilder(Type... types)
     {
         return rowPagesBuilder(ImmutableList.copyOf(types));
     }
 
     public static RowPagesBuilder rowPagesBuilder(Iterable<Typetypes)
     {
         return new RowPagesBuilder(types);
     }
 
     public static RowPagesBuilder rowPagesBuilder(boolean hashEnabledList<IntegerhashChannelsType... types)
     {
         return rowPagesBuilder(hashEnabledhashChannels, ImmutableList.copyOf(types));
     }
 
     public static RowPagesBuilder rowPagesBuilder(boolean hashEnabledList<IntegerhashChannelsIterable<Typetypes)
     {
         return new RowPagesBuilder(hashEnabled, Optional.of(hashChannels), types);
     }
 
     private final ImmutableList.Builder<Pagepages = ImmutableList.builder();
     private final List<Typetypes;
     private RowPageBuilder builder;
     private final boolean hashEnabled;
     private final Optional<List<Integer>> hashChannels;
 
     RowPagesBuilder(Iterable<Typetypes)
     {
         this(false, Optional.empty(), types);
     }
 
     RowPagesBuilder(boolean hashEnabledOptional<List<Integer>> hashChannelsIterable<Typetypes)
     {
         this. = ImmutableList.copyOf(checkNotNull(types"types is null"));
         this. = hashEnabled;
         this. = hashChannels;
          = rowPageBuilder(types);
     }
 
     public RowPagesBuilder addSequencePage(int lengthint... initialValues)
     {
         checkArgument(length > 0, "length must be at least 1");
         checkNotNull(initialValues"initialValues is null");
         checkArgument(initialValues.length == .size(), "Expected %s initialValues, but got %s".size(), initialValues.length);
 
         pageBreak();
         Page page = SequencePageBuilder.createSequencePage(lengthinitialValues);
         .add(page);
         return this;
     }
 
     public RowPagesBuilder addBlocksPage(Block... blocks)
     {
         .add(new Page(blocks));
         return this;
     }
 
     public RowPagesBuilder row(Object... values)
     {
         .row(values);
         return this;
     }
 
     public RowPagesBuilder rows(Object[]... rows)
     {
         for (Object[] row : rows) {
             row(row);
        }
        return this;
    }
    public RowPagesBuilder pageBreak()
    {
        if (!.isEmpty()) {
            .add(.build());
             = rowPageBuilder();
        }
        return this;
    }
    public List<Pagebuild()
    {
        pageBreak();
        List<PageresultPages = .build();
        if () {
            return pagesWithHash(resultPages);
        }
        return resultPages;
    }
    private List<PagepagesWithHash(List<Pagepages)
    {
        ImmutableList.Builder<PageresultPages = ImmutableList.builder();
        for (Page page : pages) {
            resultPages.add(TypeUtils.getHashPage(page.get()));
        }
        return resultPages.build();
    }
    public List<TypegetTypes()
    {
        if () {
            return ImmutableList.copyOf(Iterables.concat(, ImmutableList.of(.)));
        }
        return ;
    }
    public Optional<IntegergetHashChannel()
    {
        if () {
            return Optional.of(.size());
        }
        return Optional.empty();
    }
New to GrepCode? Check out our FAQ X