content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You 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 org.apache.carbondata.core.datastore.chunk.impl;
  
  import java.io.IOException;
  import java.nio.ByteBuffer;
  
  import org.apache.carbondata.core.datastore.FileReader;
  import org.apache.carbondata.core.datastore.ReusableDataBuffer;
  import org.apache.carbondata.core.datastore.chunk.AbstractRawColumnChunk;
  import org.apache.carbondata.core.datastore.chunk.reader.MeasureColumnChunkReader;
  import org.apache.carbondata.core.datastore.page.ColumnPage;
  import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
  
  /**
   * Contains raw measure data
   * 1. The read uncompressed raw data of column chunk with all pages is stored in this instance.
   * 2. The raw data can be converted to processed chunk using decodeColumnPage method
   *  by specifying page number.
   */
  public class MeasureRawColumnChunk extends AbstractRawColumnChunk {
  
    private ColumnPage[] columnPages;
  
    private MeasureColumnChunkReader chunkReader;
  
    private FileReader fileReader;
  
    public MeasureRawColumnChunk(int columnIndex, ByteBuffer rawData, long offSet, int length,
        MeasureColumnChunkReader chunkReader) {
      super(columnIndex, rawData, offSet, length);
      this.chunkReader = chunkReader;
    }
  
    /**
     * Convert all raw data with all pages to processed ColumnPage
     */
    public ColumnPage[] decodeAllColumnPages() {
      if (columnPages == null) {
        columnPages = new ColumnPage[pagesCount];
      }
      for (int i = 0; i < pagesCount; i++) {
        try {
          if (columnPages[i] == null) {
            columnPages[i] = chunkReader.decodeColumnPage(this, i, null);
          }
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
  
      return columnPages;
    }
  
    /**
     * Convert raw data with specified `columnIndex` processed to ColumnPage
     */
    public ColumnPage decodeColumnPage(int pageNumber) {
      assert pageNumber < pagesCount;
      if (columnPages == null) {
        columnPages = new ColumnPage[pagesCount];
      }
  
      try {
        if (columnPages[pageNumber] == null) {
          columnPages[pageNumber] = chunkReader.decodeColumnPage(this, pageNumber, null);
        }
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
  
      return columnPages[pageNumber];
    }
  
    /**
     * Convert raw data with specified page number processed to MeasureColumnDataChunk
     *
     * @param index
     * @return
     */
    public ColumnPage convertToColumnPageWithOutCache(int index,
        ReusableDataBuffer reusableDataBuffer) {
      assert index < pagesCount;
      // in case of filter query filter columns blocklet pages will uncompressed
      // so no need to decode again
      if (null != columnPages && columnPages[index] != null) {
        return columnPages[index];
      }
      try {
        return chunkReader.decodeColumnPage(this, index, reusableDataBuffer);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  
    /**
     * Convert raw data with specified page number processed to DimensionColumnDataChunk and fill the
     * vector
     *
     * @param pageNumber page number to decode and fill the vector
     * @param vectorInfo vector to be filled with column page
     */
    public void convertToColumnPageAndFillVector(int pageNumber, ColumnVectorInfo vectorInfo,
        ReusableDataBuffer reusableDataBuffer) {
      assert pageNumber < pagesCount;
      try {
        chunkReader.decodeColumnPageAndFillVector(this, pageNumber, vectorInfo, reusableDataBuffer);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  
    @Override
    public void freeMemory() {
      super.freeMemory();
      if (null != columnPages) {
        for (int i = 0; i < columnPages.length; i++) {
          if (columnPages[i] != null) {
            columnPages[i].freeMemory();
            columnPages[i] = null;
          }
        }
      }
      rawData = null;
    }
  
    public void setFileReader(FileReader fileReader) {
      this.fileReader = fileReader;
    }
  
    public FileReader getFileReader() {
      return fileReader;
    }
  }
  