/**
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *  All rights reserved. This program and the accompanying materials 
 *  are made available under the terms of the Eclipse Public License v1.0 
 *  which accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html 
 * 
 *  Based on ideas from Xtext, Xtend, Xcore
 *   
 *  Contributors:  
 *  		Joerg Riegel - Initial implementation 
 *  
 */
package org.eclipse.osbp.xtext.datamartdsl;

import org.eclipse.osbp.xtext.cubedsl.CubeHierarchy;
import org.eclipse.osbp.xtext.cubedsl.CubeLevel;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Datamart Hierarchy</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isDefaultMember <em>Default Member</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAllMember <em>All Member</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAllLevels <em>All Levels</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAll <em>All</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isExcept <em>Except</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isOrdered <em>Ordered</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isDescending <em>Descending</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getHierarchyRef <em>Hierarchy Ref</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getLevelRef <em>Level Ref</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getExceptRef <em>Except Ref</em>}</li>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getOrderRef <em>Order Ref</em>}</li>
 * </ul>
 *
 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy()
 * @model
 * @generated
 */
public interface DatamartHierarchy extends Expression, DatamartElement {
	/**
	 * Returns the value of the '<em><b>Default Member</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Default Member</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Default Member</em>' attribute.
	 * @see #setDefaultMember(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_DefaultMember()
	 * @model unique="false"
	 * @generated
	 */
	boolean isDefaultMember();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isDefaultMember <em>Default Member</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Default Member</em>' attribute.
	 * @see #isDefaultMember()
	 * @generated
	 */
	void setDefaultMember(boolean value);

	/**
	 * Returns the value of the '<em><b>All Member</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>All Member</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>All Member</em>' attribute.
	 * @see #setAllMember(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_AllMember()
	 * @model unique="false"
	 * @generated
	 */
	boolean isAllMember();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAllMember <em>All Member</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>All Member</em>' attribute.
	 * @see #isAllMember()
	 * @generated
	 */
	void setAllMember(boolean value);

	/**
	 * Returns the value of the '<em><b>All Levels</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>All Levels</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>All Levels</em>' attribute.
	 * @see #setAllLevels(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_AllLevels()
	 * @model unique="false"
	 * @generated
	 */
	boolean isAllLevels();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAllLevels <em>All Levels</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>All Levels</em>' attribute.
	 * @see #isAllLevels()
	 * @generated
	 */
	void setAllLevels(boolean value);

	/**
	 * Returns the value of the '<em><b>All</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>All</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>All</em>' attribute.
	 * @see #setAll(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_All()
	 * @model unique="false"
	 * @generated
	 */
	boolean isAll();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isAll <em>All</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>All</em>' attribute.
	 * @see #isAll()
	 * @generated
	 */
	void setAll(boolean value);

	/**
	 * Returns the value of the '<em><b>Except</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Except</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Except</em>' attribute.
	 * @see #setExcept(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_Except()
	 * @model unique="false"
	 * @generated
	 */
	boolean isExcept();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isExcept <em>Except</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Except</em>' attribute.
	 * @see #isExcept()
	 * @generated
	 */
	void setExcept(boolean value);

	/**
	 * Returns the value of the '<em><b>Ordered</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Ordered</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Ordered</em>' attribute.
	 * @see #setOrdered(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_Ordered()
	 * @model unique="false"
	 * @generated
	 */
	boolean isOrdered();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isOrdered <em>Ordered</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Ordered</em>' attribute.
	 * @see #isOrdered()
	 * @generated
	 */
	void setOrdered(boolean value);

	/**
	 * Returns the value of the '<em><b>Descending</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Descending</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Descending</em>' attribute.
	 * @see #setDescending(boolean)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_Descending()
	 * @model unique="false"
	 * @generated
	 */
	boolean isDescending();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#isDescending <em>Descending</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Descending</em>' attribute.
	 * @see #isDescending()
	 * @generated
	 */
	void setDescending(boolean value);

	/**
	 * Returns the value of the '<em><b>Hierarchy Ref</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Hierarchy Ref</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Hierarchy Ref</em>' reference.
	 * @see #setHierarchyRef(CubeHierarchy)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_HierarchyRef()
	 * @model
	 * @generated
	 */
	CubeHierarchy getHierarchyRef();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getHierarchyRef <em>Hierarchy Ref</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Hierarchy Ref</em>' reference.
	 * @see #getHierarchyRef()
	 * @generated
	 */
	void setHierarchyRef(CubeHierarchy value);

	/**
	 * Returns the value of the '<em><b>Level Ref</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Level Ref</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Level Ref</em>' reference.
	 * @see #setLevelRef(CubeLevel)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_LevelRef()
	 * @model
	 * @generated
	 */
	CubeLevel getLevelRef();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getLevelRef <em>Level Ref</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Level Ref</em>' reference.
	 * @see #getLevelRef()
	 * @generated
	 */
	void setLevelRef(CubeLevel value);

	/**
	 * Returns the value of the '<em><b>Except Ref</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Except Ref</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Except Ref</em>' reference.
	 * @see #setExceptRef(CubeLevel)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_ExceptRef()
	 * @model
	 * @generated
	 */
	CubeLevel getExceptRef();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getExceptRef <em>Except Ref</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Except Ref</em>' reference.
	 * @see #getExceptRef()
	 * @generated
	 */
	void setExceptRef(CubeLevel value);

	/**
	 * Returns the value of the '<em><b>Order Ref</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Order Ref</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Order Ref</em>' containment reference.
	 * @see #setOrderRef(DatamartElement)
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage#getDatamartHierarchy_OrderRef()
	 * @model containment="true"
	 * @generated
	 */
	DatamartElement getOrderRef();

	/**
	 * Sets the value of the '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy#getOrderRef <em>Order Ref</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Order Ref</em>' containment reference.
	 * @see #getOrderRef()
	 * @generated
	 */
	void setOrderRef(DatamartElement value);

} // DatamartHierarchy
