/*

  * 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 javax.faces.webapp;

 import javax.faces.application.Application;

 import javax.faces.component.UIComponent;

 import javax.faces.context.FacesContext;

 import javax.faces.el.ValueBinding;

 import javax.servlet.jsp.JspException;

 import javax.servlet.jsp.PageContext;

 import javax.servlet.jsp.tagext.Tag;

 /**

  * Base class for all JSP tags that represent a JSF UIComponent.

  * <p>

  * <i>Disclaimer</i>: The official definition for the behaviour of this class is the JSF specification but for legal

  * reasons the specification cannot be replicated here. Any javadoc present on this class therefore describes the

  * current implementation rather than the officially required behaviour, though it is believed that this class does

  * comply with the specification.

  * 

  * see Javadoc of <a href="http://java.sun.com/j2ee/javaserverfaces/1.2/docs/api/index.html">JSF Specification</a> for

  * more.

  * 

  * @deprecated replaced by {@link UIComponentELTag}

  */

 public abstract class UIComponentTag extends UIComponentClassicTagBase

 {

     // tag attributes

     private String _binding = null;

     private String _rendered = null;

     private Boolean _suppressed = null;

     public UIComponentTag()

     {

     }

     @Override

     public void release()

     {

         super.release();

         _binding = null;

         _rendered = null;

     }

     /** Setter for common JSF xml attribute "binding". 

      * @throws JspException 

      */

     public void setBinding(String binding) throws JspException

     {

         if (!isValueReference(binding))

         {

             throw new IllegalArgumentException("not a valid binding: " + binding);

         }

         _binding = binding;

     }

     /** Setter for common JSF xml attribute "rendered". */

     public void setRendered(String rendered)

     {

         _rendered = rendered;

     }

     /**

      * Return the nearest JSF tag that encloses this tag.

      * 

      * @deprecated

      */

     public static UIComponentTag getParentUIComponentTag(PageContext pageContext)

     {

         UIComponentClassicTagBase parentTag = getParentUIComponentClassicTagBase(pageContext);

         return parentTag instanceof UIComponentTag ? (UIComponentTag)parentTag : new UIComponentTagWrapper(parentTag);

     }

     /**

      * Return true if the specified string contains an EL expression.

      * <p>

      * UIComponent properties are often required to be value-binding expressions; this method allows code to check

      * whether that is the case or not.

      */

     public static boolean isValueReference(String value)

     {

         if (value == null)

         {

             throw new NullPointerException("value");

         }

         int start = value.indexOf("#{");

         if (start < 0)

         {

             return false;

         }

         int end = value.lastIndexOf('}');

         return (end >= 0 && start < end);

     }

     /**

      * Create a UIComponent. Abstract method getComponentType is invoked to determine the actual type name for the

      * component to be created.

      * 

      * If this tag has a "binding" attribute, then that is immediately evaluated to store the created component in the

      * specified property.

      */

     @Override

     protected UIComponent createComponent(FacesContext context, String id)

     {

         String componentType = getComponentType();

         if (componentType == null)

         {

             throw new NullPointerException("componentType");

         }

         if (_binding != null)

         {

             Application application = context.getApplication();

             ValueBinding componentBinding = application.createValueBinding(_binding);

             UIComponent component = application.createComponent(componentBinding, context, componentType);

             component.setId(id);

             component.setValueBinding("binding", componentBinding);

             setProperties(component);

             return component;

         }

         UIComponent component = context.getApplication().createComponent(componentType);

         component.setId(id);

         setProperties(component);

         return component;

     }

     private boolean isFacet()

     {

         return getParent() != null && getParent() instanceof FacetTag;

     }

     /**

      * Determine whether this component renders itself. A component is "suppressed" when it is either not rendered, or

      * when it is rendered by its parent component at a time of the parent's choosing.

      */

     protected boolean isSuppressed()

     {

         if (_suppressed == null)

         {

             // we haven't called this method before, so determine the suppressed

             // value and cache it for later calls to this method.

             if (isFacet())

             {

                 // facets are always rendered by their parents --> suppressed

                 _suppressed = Boolean.TRUE;

                 return true;

             }

             UIComponent component = getComponentInstance();

             // Does any parent render its children?

             // (We must determine this first, before calling any isRendered method

             // because rendered properties might reference a data var of a nesting UIData,

             // which is not set at this time, and would cause a VariableResolver error!)

             UIComponent parent = component.getParent();

             while (parent != null)

             {

                 if (parent.getRendersChildren())

                 {

                     // Yes, parent found, that renders children --> suppressed

                     _suppressed = Boolean.TRUE;

                     return true;

                 }

                 parent = parent.getParent();

             }

             // does component or any parent has a false rendered attribute?

             while (component != null)

             {

                 if (!component.isRendered())

                 {

                     // Yes, component or any parent must not be rendered --> suppressed

                     _suppressed = Boolean.TRUE;

                     return true;

                 }

                 component = component.getParent();

             }

             // else --> not suppressed

             _suppressed = Boolean.FALSE;

         }

         return _suppressed.booleanValue();

     }

     @Override

     protected void setProperties(UIComponent component)

     {

         if (getRendererType() != null)

         {

             component.setRendererType(getRendererType());

         }

         if (_rendered != null)

         {

             if (isValueReference(_rendered))

             {

                 ValueBinding vb = getFacesContext().getApplication().createValueBinding(_rendered);

                 component.setValueBinding("rendered", vb);

             }

             else

             {

                 boolean b = Boolean.valueOf(_rendered).booleanValue();

                 component.setRendered(b);

             }

         }

     }

     /**

      * Class used to create an UIComponentTag from a UIComponentClassicTagBase.

      * <p>

      * This is a standard use of the decorator pattern, to make the logic of the JSF12 UIComponentClassicTagBase class

      * available via the old JSF11 UIComponentTag api.

      */

     private static class UIComponentTagWrapper extends UIComponentTag

     {

         private UIComponentClassicTagBase target;

         public UIComponentTagWrapper(UIComponentClassicTagBase classicTag)

         {

             target = classicTag;

         }

         // -----------------------------------------------------------

         // Methods that can reasonably be called on a parent tag object

         // -----------------------------------------------------------

         @Override

         public String getComponentType()

         {

             return target.getComponentType();

         }

         @Override

         public String getRendererType()

         {

             return target.getRendererType();

         }

         @Override

         public boolean getCreated()

         {

             return target.getCreated();

         }

         @Override

         public String getId()

         {

             return target.getId();

         }

         @Override

         public UIComponent getComponentInstance()

         {

             return target.getComponentInstance();

         }

         @Override

         public Tag getParent()

         {

             return target.getParent();

         }

         // -----------------------------------------------------------

         // Methods that should never be called on a parent tag object

         // -----------------------------------------------------------

         @Override

         public void release()

         {

             throw new UnsupportedOperationException();

         }

         @Override

         public void setBinding(String binding) throws JspException

         {

             throw new UnsupportedOperationException();

         }

         @Override

         public void setId(String id)

         {

             throw new UnsupportedOperationException();

         }

         @Override

         public void setRendered(String state)

         {

             throw new UnsupportedOperationException();

         }

         @Override

         protected UIComponent createComponent(FacesContext context, String newId)

         {

             throw new UnsupportedOperationException();

         }

         @Override

         public void setPageContext(PageContext context)

         {

             throw new UnsupportedOperationException();

         }

         @Override

         public void setParent(Tag parent)

         {

             throw new UnsupportedOperationException();

         }

         @Override

         protected UIComponent findComponent(FacesContext context) throws JspException

         {

             throw new UnsupportedOperationException();

         }

         @Override

         protected FacesContext getFacesContext()

         {

             throw new UnsupportedOperationException();

         }

         // Methods that no sane user of this class would call, so we do not need to override here:

         // doStartTag, doEndTag, getDoStartValue, getDoEndValue, isSupressed

         // encodeBegin, encodeChildren, encodeEnd, getFacetName

         // setProperties, setupResponseWriter

     }

     @Override

     protected boolean hasBinding()

     {

         return _binding != null;

     }

 }