org.apache.poi.hssf.usermodel.HSSFCellStyle Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
/* ====================================================================
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.poi.hssf.usermodel;
import java.util.List;
import java.util.Objects;
import org.apache.poi.common.Duplicatable;
import org.apache.poi.hssf.model.InternalWorkbook;
import org.apache.poi.hssf.record.ExtendedFormatRecord;
import org.apache.poi.hssf.record.FontRecord;
import org.apache.poi.hssf.record.FormatRecord;
import org.apache.poi.hssf.record.StyleRecord;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.hssf.util.HSSFColor.HSSFColorPredefined;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.util.Removal;
/**
* High level representation of the style of a cell in a sheet of a workbook.
*
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#createCellStyle()
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#getCellStyleAt(int)
* @see org.apache.poi.hssf.usermodel.HSSFCell#setCellStyle(HSSFCellStyle)
*/
public final class HSSFCellStyle implements CellStyle, Duplicatable {
private final ExtendedFormatRecord _format;
private final short _index;
private final InternalWorkbook _workbook;
/** Creates new HSSFCellStyle why would you want to do this?? */
protected HSSFCellStyle(short index, ExtendedFormatRecord rec, HSSFWorkbook workbook)
{
this(index, rec, workbook.getWorkbook());
}
protected HSSFCellStyle(short index, ExtendedFormatRecord rec, InternalWorkbook workbook)
{
_workbook = workbook;
_index = index;
_format = rec;
}
protected HSSFCellStyle(HSSFCellStyle other) {
_workbook = other._workbook;
_index = other._index;
_format = other._format;
}
/**
* get the index within the HSSFWorkbook (sequence within the collection of ExtendedFormat objects)
* @return unique index number of the underlying record this style represents (probably you don't care
* unless you're comparing which one is which)
*/
@Override
public short getIndex() {
return _index;
}
/**
* Return the parent style for this cell style.
* In most cases this will be null, but in a few
* cases there'll be a fully defined parent.
*/
public HSSFCellStyle getParentStyle() {
short parentIndex = _format.getParentIndex();
// parentIndex equal 0xFFF indicates no inheritance from a cell style XF (See 2.4.353 XF)
if(parentIndex == 0 || parentIndex == 0xFFF) {
return null;
}
return new HSSFCellStyle(
parentIndex,
_workbook.getExFormatAt(parentIndex),
_workbook
);
}
/**
* set the data format (must be a valid format)
* @see org.apache.poi.hssf.usermodel.HSSFDataFormat
*/
@Override
public void setDataFormat(short fmt)
{
_format.setFormatIndex(fmt);
}
/**
* get the index of the format
* @see org.apache.poi.hssf.usermodel.HSSFDataFormat
*/
@Override
public short getDataFormat()
{
return _format.getFormatIndex();
}
// we keep the cached data in ThreadLocal members in order to
// avoid multi-threading issues when different workbooks are accessed in
// multiple threads at the same time
private static final ThreadLocal lastDateFormat = ThreadLocal.withInitial(() -> Short.MIN_VALUE);
private static final ThreadLocal> lastFormats = new ThreadLocal<>();
private static final ThreadLocal getDataFormatStringCache = new ThreadLocal<>();
/**
* Get the contents of the format string, by looking up
* the DataFormat against the bound workbook
* @see org.apache.poi.hssf.usermodel.HSSFDataFormat
* @return the format string or "General" if not found
*/
@Override
public String getDataFormatString() {
if (getDataFormatStringCache.get() != null) {
if (lastDateFormat.get() == getDataFormat() && _workbook.getFormats().equals(lastFormats.get())) {
return getDataFormatStringCache.get();
}
}
lastFormats.set(_workbook.getFormats());
lastDateFormat.set(getDataFormat());
getDataFormatStringCache.set(getDataFormatString(_workbook));
return getDataFormatStringCache.get();
}
/**
* Get the contents of the format string, by looking up
* the DataFormat against the supplied workbook
* @see org.apache.poi.hssf.usermodel.HSSFDataFormat
*
* @return the format string or "General" if not found
*/
public String getDataFormatString(org.apache.poi.ss.usermodel.Workbook workbook) {
HSSFDataFormat format = new HSSFDataFormat( ((HSSFWorkbook)workbook).getWorkbook() );
int idx = getDataFormat();
return idx == -1 ? "General" : format.getFormat(getDataFormat());
}
/**
* Get the contents of the format string, by looking up
* the DataFormat against the supplied low level workbook
* @see org.apache.poi.hssf.usermodel.HSSFDataFormat
*/
public String getDataFormatString(org.apache.poi.hssf.model.InternalWorkbook workbook) {
HSSFDataFormat format = new HSSFDataFormat( workbook );
return format.getFormat(getDataFormat());
}
/**
* set the font for this style
* @param font a font object created or retrieved from the HSSFWorkbook object
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#createFont()
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#getFontAt(int)
*/
@Override
public void setFont(Font font) {
setFont((HSSFFont)font);
}
public void setFont(HSSFFont font) {
_format.setIndentNotParentFont(true);
short fontindex = (short) font.getIndex();
_format.setFontIndex(fontindex);
}
/**
* gets the index of the font for this style
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#getFontAt(int)
* @since 5.0.0 (used to return a short value)
*/
@Override
public int getFontIndex()
{
return _format.getFontIndex();
}
/**
* gets the index of the font for this style
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#getFontAt(int)
* @deprecated use {@link #getFontIndex()} instead
* @since 4.0.0
*/
@Deprecated
@Removal(version = "6.0.0")
@Override
public int getFontIndexAsInt()
{
return _format.getFontIndex();
}
/**
* gets the font for this style
* @param parentWorkbook The HSSFWorkbook that this style belongs to
* @see org.apache.poi.hssf.usermodel.HSSFCellStyle#getFontIndex()
* @see org.apache.poi.hssf.usermodel.HSSFWorkbook#getFontAt(int)
*/
public HSSFFont getFont(org.apache.poi.ss.usermodel.Workbook parentWorkbook) {
return ((HSSFWorkbook) parentWorkbook).getFontAt(getFontIndex());
}
/**
* set the cell's using this style to be hidden
* @param hidden - whether the cell using this style should be hidden
*/
@Override
public void setHidden(boolean hidden)
{
_format.setIndentNotParentCellOptions(true);
_format.setHidden(hidden);
}
/**
* get whether the cell's using this style are to be hidden
* @return hidden - whether the cell using this style should be hidden
*/
@Override
public boolean getHidden()
{
return _format.isHidden();
}
/**
* set the cell's using this style to be locked
* @param locked - whether the cell using this style should be locked
*/
@Override
public void setLocked(boolean locked)
{
_format.setIndentNotParentCellOptions(true);
_format.setLocked(locked);
}
/**
* get whether the cell's using this style are to be locked
* @return hidden - whether the cell using this style should be locked
*/
@Override
public boolean getLocked()
{
return _format.isLocked();
}
/**
* Turn on or off "Quote Prefix" or "123 Prefix" for the style,
* which is used to tell Excel that the thing which looks like
* a number or a formula shouldn't be treated as on.
*/
@Override
public void setQuotePrefixed(boolean quotePrefix) {
_format.set123Prefix(quotePrefix);
}
/**
* Is "Quote Prefix" or "123 Prefix" enabled for the cell?
*/
@Override
public boolean getQuotePrefixed() {
return _format.get123Prefix();
}
/**
* set the type of horizontal alignment for the cell
* @param align - the type of alignment
*/
@Override
public void setAlignment(HorizontalAlignment align)
{
_format.setIndentNotParentAlignment(true);
_format.setAlignment(align.getCode());
}
@Override
public HorizontalAlignment getAlignment()
{
return HorizontalAlignment.forInt(_format.getAlignment());
}
/**
* set whether the text should be wrapped
* @param wrapped wrap text or not
*/
@Override
public void setWrapText(boolean wrapped)
{
_format.setIndentNotParentAlignment(true);
_format.setWrapText(wrapped);
}
/**
* get whether the text should be wrapped
* @return wrap text or not
*/
@Override
public boolean getWrapText()
{
return _format.getWrapText();
}
/**
* set the type of vertical alignment for the cell
* @param align the type of alignment
*/
@Override
public void setVerticalAlignment(VerticalAlignment align)
{
_format.setVerticalAlignment(align.getCode());
}
@Override
public VerticalAlignment getVerticalAlignment() {
return VerticalAlignment.forInt(_format.getVerticalAlignment());
}
/**
* set the degree of rotation for the text in the cell
*
* Note: HSSF uses values from -90 to 90 degrees, whereas XSSF
* uses values from 0 to 180 degrees. The implementations of this method will map between these two value-ranges
* accordingly, however the corresponding getter is returning values in the range mandated by the current type
* of Excel file-format that this CellStyle is applied to.
*
* @param rotation degrees (between -90 and 90 degrees, of 0xff for vertical)
*/
@Override
public void setRotation(short rotation)
{
if (rotation == 0xff) {
// Special cases for vertically aligned text
}
else if ((rotation < 0)&&(rotation >= -90)) {
//Take care of the funny 4th quadrant issue
//The 4th quadrant (-1 to -90) is stored as (91 to 180)
rotation = (short)(90 - rotation);
}
else if (rotation > 90 && rotation <= 180) {
// stay compatible with the range used by XSSF, map from ]90..180] to ]0..-90]
// we actually don't need to do anything here as the internal value is stored in [0-180] anyway!
}
else if ((rotation < -90) || (rotation > 90)) {
//Do not allow an incorrect rotation to be set
throw new IllegalArgumentException("The rotation must be between -90 and 90 degrees, or 0xff");
}
_format.setRotation(rotation);
}
/**
* get the degree of rotation for the text in the cell
* @return rotation degrees (between -90 and 90 degrees, or 0xff for vertical)
*/
@Override
public short getRotation()
{
short rotation = _format.getRotation();
if (rotation == 0xff) {
// Vertical aligned special case
return rotation;
}
if (rotation > 90) {
//This is actually the 4th quadrant
rotation = (short)(90-rotation);
}
return rotation;
}
/**
* set the number of spaces to indent the text in the cell
* @param indent - number of spaces
*/
@Override
public void setIndention(short indent)
{
_format.setIndent(indent);
}
/**
* get the number of spaces to indent the text in the cell
* @return indent - number of spaces
*/
@Override
public short getIndention()
{
return _format.getIndent();
}
/**
* set the type of border to use for the left border of the cell
* @param border type
* @since POI 3.15
*/
@Override
public void setBorderLeft(BorderStyle border)
{
_format.setIndentNotParentBorder(true);
_format.setBorderLeft(border.getCode());
}
@Override
public BorderStyle getBorderLeft()
{
return BorderStyle.valueOf(_format.getBorderLeft());
}
/**
* set the type of border to use for the right border of the cell
* @param border type
* @since POI 3.15
*/
@Override
public void setBorderRight(BorderStyle border)
{
_format.setIndentNotParentBorder(true);
_format.setBorderRight(border.getCode());
}
@Override
public BorderStyle getBorderRight()
{
return BorderStyle.valueOf(_format.getBorderRight());
}
/**
* set the type of border to use for the top border of the cell
* @param border type
* @since POI 3.15
*/
@Override
public void setBorderTop(BorderStyle border)
{
_format.setIndentNotParentBorder(true);
_format.setBorderTop(border.getCode());
}
@Override
public BorderStyle getBorderTop()
{
return BorderStyle.valueOf(_format.getBorderTop());
}
/**
* set the type of border to use for the bottom border of the cell
* @param border type
* @since 3.15 beta 2
*/
@Override
public void setBorderBottom(BorderStyle border)
{
_format.setIndentNotParentBorder(true);
_format.setBorderBottom(border.getCode());
}
@Override
public BorderStyle getBorderBottom()
{
return BorderStyle.valueOf(_format.getBorderBottom());
}
/**
* set the color to use for the left border
* @param color The index of the color definition
*/
@Override
public void setLeftBorderColor(short color)
{
_format.setLeftBorderPaletteIdx(color);
}
/**
* get the color to use for the left border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return The index of the color definition
*/
@Override
public short getLeftBorderColor()
{
return _format.getLeftBorderPaletteIdx();
}
/**
* set the color to use for the right border
* @param color The index of the color definition
*/
@Override
public void setRightBorderColor(short color)
{
_format.setRightBorderPaletteIdx(color);
}
/**
* get the color to use for the left border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return The index of the color definition
*/
@Override
public short getRightBorderColor()
{
return _format.getRightBorderPaletteIdx();
}
/**
* set the color to use for the top border
* @param color The index of the color definition
*/
@Override
public void setTopBorderColor(short color)
{
_format.setTopBorderPaletteIdx(color);
}
/**
* get the color to use for the top border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return The index of the color definition
*/
@Override
public short getTopBorderColor()
{
return _format.getTopBorderPaletteIdx();
}
/**
* set the color to use for the bottom border
* @param color The index of the color definition
*/
@Override
public void setBottomBorderColor(short color)
{
_format.setBottomBorderPaletteIdx(color);
}
/**
* get the color to use for the left border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return The index of the color definition
*/
@Override
public short getBottomBorderColor()
{
return _format.getBottomBorderPaletteIdx();
}
/**
* setting to one fills the cell with the foreground color... No idea about
* other values
*
* @param fp fill pattern (set to {@link FillPatternType#SOLID_FOREGROUND} to fill w/foreground color)
*/
@Override
public void setFillPattern(FillPatternType fp)
{
_format.setAdtlFillPattern(fp.getCode());
}
@Override
public FillPatternType getFillPattern()
{
return FillPatternType.forInt(_format.getAdtlFillPattern());
}
/**
* Checks if the background and foreground fills are set correctly when one
* or the other is set to the default color.
* Works like the logic table below:
* BACKGROUND FOREGROUND
* NONE AUTOMATIC
* 0x41 0x40
* NONE RED/ANYTHING
* 0x40 0xSOMETHING
*/
private void checkDefaultBackgroundFills() {
final short autoIdx = HSSFColorPredefined.AUTOMATIC.getIndex();
if (_format.getFillForeground() == autoIdx) {
//JMH: Why +1, hell why not. I guess it made some sense to someone at the time. Doesnt
//to me now.... But experience has shown that when the fore is set to AUTOMATIC then the
//background needs to be incremented......
if (_format.getFillBackground() != autoIdx+1) {
setFillBackgroundColor((short)(autoIdx+1));
}
} else if (_format.getFillBackground() == autoIdx+1) {
//Now if the forground changes to a non-AUTOMATIC color the background resets itself!!!
if (_format.getFillForeground() != autoIdx) {
setFillBackgroundColor(autoIdx);
}
}
}
/**
* set the background fill color.
*
* For example:
*
* cs.setFillPattern(HSSFCellStyle.FINE_DOTS );
* cs.setFillBackgroundColor(new HSSFColor.RED().getIndex());
*
* optionally a Foreground and background fill can be applied:
* Note: Ensure Foreground color is set prior to background
*
* cs.setFillPattern(HSSFCellStyle.FINE_DOTS );
* cs.setFillForegroundColor(new HSSFColor.BLUE().getIndex());
* cs.setFillBackgroundColor(new HSSFColor.RED().getIndex());
*
* or, for the special case of SOLID_FILL:
*
* cs.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND );
* cs.setFillForegroundColor(new HSSFColor.RED().getIndex());
*
* It is necessary to set the fill style in order
* for the color to be shown in the cell.
*
* @param bg color
*/
@Override
public void setFillBackgroundColor(short bg)
{
_format.setFillBackground(bg);
checkDefaultBackgroundFills();
}
/**
* Set the background fill color represented as a {@link org.apache.poi.ss.usermodel.Color} value.
*
* @param color the color to use
* @throws IllegalArgumentException if you provide a Color instance that is not a {@link HSSFColor}
* @since POI 5.2.3
*/
@Override
public void setFillBackgroundColor(org.apache.poi.ss.usermodel.Color color)
{
if (color instanceof HSSFColor) {
short index2 = ((HSSFColor)color).getIndex2();
if (index2 != -1) setFillBackgroundColor(index2);
} else if (color != null) {
throw new IllegalArgumentException("HSSFCellStyle only accepts HSSFColor instances");
}
}
/**
* Get the background fill color.
* Note - many cells are actually filled with a foreground
* fill, not a background fill - see {@link #getFillForegroundColor()}
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return fill color
*/
@Override
public short getFillBackgroundColor() {
final short autoIndex = HSSFColorPredefined.AUTOMATIC.getIndex();
short result = _format.getFillBackground();
//JMH: Do this ridiculous conversion, and let HSSFCellStyle
//internally migrate back and forth
if (result == autoIndex+1) {
return autoIndex;
}
return result;
}
@Override
public HSSFColor getFillBackgroundColorColor() {
HSSFPalette pallette = new HSSFPalette(
_workbook.getCustomPalette()
);
return pallette.getColor(
getFillBackgroundColor()
);
}
/**
* set the foreground fill color
* Note: Ensure Foreground color is set prior to background color.
* @param bg color
*/
@Override
public void setFillForegroundColor(short bg)
{
_format.setFillForeground(bg);
checkDefaultBackgroundFills();
}
/**
* Set the foreground fill color represented as a {@link org.apache.poi.ss.usermodel.Color} value.
*
* @param color the color to use
* @throws IllegalArgumentException if you provide a Color instance that is not a {@link HSSFColor}
* @since POI 5.2.3
*/
@Override
public void setFillForegroundColor(org.apache.poi.ss.usermodel.Color color)
{
if (color instanceof HSSFColor) {
short index2 = ((HSSFColor)color).getIndex2();
if (index2 != -1) setFillForegroundColor(index2);
} else if (color != null) {
throw new IllegalArgumentException("HSSFCellStyle only accepts HSSFColor instances");
}
}
/**
* Get the foreground fill color.
* Many cells are filled with this, instead of a
* background color ({@link #getFillBackgroundColor()})
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return fill color
*/
@Override
public short getFillForegroundColor()
{
return _format.getFillForeground();
}
@Override
public HSSFColor getFillForegroundColorColor() {
HSSFPalette pallette = new HSSFPalette(
_workbook.getCustomPalette()
);
return pallette.getColor(
getFillForegroundColor()
);
}
/**
* Gets the name of the user defined style.
* Returns null for built in styles, and
* styles where no name has been defined
*/
public String getUserStyleName() {
StyleRecord sr = _workbook.getStyleRecord(_index);
if(sr == null) {
return null;
}
if(sr.isBuiltin()) {
return null;
}
return sr.getName();
}
/**
* Sets the name of the user defined style.
* Will complain if you try this on a built in style.
*/
public void setUserStyleName(String styleName) {
StyleRecord sr = _workbook.getStyleRecord(_index);
if(sr == null) {
sr = _workbook.createStyleRecord(_index);
}
// All Style records start as "builtin", but generally
// only 20 and below really need to be
if(sr.isBuiltin() && _index <= 20) {
throw new IllegalArgumentException("Unable to set user specified style names for built in styles!");
}
sr.setName(styleName);
}
/**
* Controls if the Cell should be auto-sized
* to shrink to fit if the text is too long
*/
@Override
public void setShrinkToFit(boolean shrinkToFit) {
_format.setShrinkToFit(shrinkToFit);
}
/**
* Should the Cell be auto-sized by Excel to shrink
* it to fit if this text is too long?
*/
@Override
public boolean getShrinkToFit() {
return _format.getShrinkToFit();
}
/**
* Get the reading order, for RTL/LTR ordering of
* the text.
* 0 means Context (Default), 1 means Left To Right,
* and 2 means Right to Left
*
* @return order - the reading order (0,1,2)
*/
public short getReadingOrder() {
return _format.getReadingOrder();
}
/**
* Sets the reading order, for RTL/LTR ordering of
* the text.
* 0 means Context (Default), 1 means Left To Right,
* and 2 means Right to Left
*
* @param order - the reading order (0,1,2)
*/
public void setReadingOrder(short order) {
_format.setReadingOrder(order);
}
/**
* Verifies that this style belongs to the supplied Workbook.
* Will throw an exception if it belongs to a different one.
* This is normally called when trying to assign a style to a
* cell, to ensure the cell and the style are from the same
* workbook (if they're not, it won't work)
* @throws IllegalArgumentException if there's a workbook mis-match
*/
public void verifyBelongsToWorkbook(HSSFWorkbook wb) {
if(wb.getWorkbook() != _workbook) {
throw new IllegalArgumentException("This Style does not belong to the supplied Workbook. Are you trying to assign a style from one workbook to the cell of a differnt workbook?");
}
}
/**
* Clones all the style information from another
* HSSFCellStyle, onto this one. This
* HSSFCellStyle will then have all the same
* properties as the source, but the two may
* be edited independently.
* Any stylings on this HSSFCellStyle will be lost!
*
* The source HSSFCellStyle could be from another
* HSSFWorkbook if you like. This allows you to
* copy styles from one HSSFWorkbook to another.
*/
@Override
public void cloneStyleFrom(CellStyle source) {
if(source instanceof HSSFCellStyle) {
this.cloneStyleFrom((HSSFCellStyle)source);
} else {
throw new IllegalArgumentException("Can only clone from one HSSFCellStyle to another, not between HSSFCellStyle and XSSFCellStyle");
}
}
public void cloneStyleFrom(HSSFCellStyle source) {
// First we need to clone the extended format
// record
_format.cloneStyleFrom(source._format);
// Handle matching things if we cross workbooks
if(_workbook != source._workbook) {
lastDateFormat.set(Short.MIN_VALUE);
lastFormats.remove();
getDataFormatStringCache.remove();
// Then we need to clone the format string,
// and update the format record for this
short fmt = (short)_workbook.createFormat(source.getDataFormatString() );
setDataFormat(fmt);
// Finally we need to clone the font,
// and update the format record for this
FontRecord fr = _workbook.createNewFont();
fr.cloneStyleFrom(
source._workbook.getFontRecordAt(
source.getFontIndex()
)
);
HSSFFont font = new HSSFFont(
(short)_workbook.getFontIndex(fr), fr
);
setFont(font);
}
}
@Override
public int hashCode() {
return Objects.hash(_format, _index);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (obj instanceof HSSFCellStyle) {
final HSSFCellStyle other = (HSSFCellStyle) obj;
if (_format == null) {
if (other._format != null) {
return false;
}
} else if (!_format.equals(other._format)) {
return false;
}
if (_index != other._index) {
return false;
}
return true;
}
return false;
}
@Override
public HSSFCellStyle copy() {
return new HSSFCellStyle(this);
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy