mapbasedinvocationfactory.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 736 行 · 第 1/2 页

      if (windowState == WindowState.NORMAL) {
        if (normalWindowStateNamespace == null && !hasParameters)
          normalWindowStateNamespace = namespace;
      }
      else {
        needNormalWindowState = true;

        String key = _windowStateParameterName;
        String value = windowState.toString();

        appendReserved( url, namespace, key, value );
      }

      if (parameterMap != null && !parameterMap.isEmpty()) 
      {
        Iterator<Map.Entry<String, String[]>> paramIter 
          = parameterMap.entrySet().iterator();

        while (paramIter.hasNext()) {
          Map.Entry<String, String[]> paramEntry = paramIter.next();

          String paramKey = paramEntry.getKey();
          String[] paramValues = paramEntry.getValue();

          if (paramValues == null || paramValues.length == 0)
            continue;

          appendParameter( url, paramNamespace, paramKey, paramValues );
        }
      }
      
    } // iterate invocationMap

    if (needViewPortletMode && viewPortletModeNamespace != null) {
      String key = _portletModeParameterName;

      if (viewPortletModeNamespace == _actionNamespace)
        viewPortletModeNamespace = null;

      appendReserved( url, viewPortletModeNamespace, key, "view" );
    }

    if (needNormalWindowState && normalWindowStateNamespace != null) {
      String key = _windowStateParameterName;

      if (normalWindowStateNamespace == _actionNamespace)
        normalWindowStateNamespace = null;

      appendReserved( url, normalWindowStateNamespace, key, "normal" );
    }

    return url.toString();
  }

  private void appendReserved( StringBuffer url, String namespace, 
                               String key, String value )
  {
    url.append(url.length() == 0 ? '?' : '&');

    url.append(_reservedNamespace);

    if (namespace != null) {
      url.append(namespace);
      url.append('.');
    }

    url.append(_reservedNamespace);
    url.append(key);
    url.append('=');
    HttpUtil.encode(value, url);
  }

  private void appendParameter( StringBuffer url, String namespace, 
                                String key, String values[] )
  {
    for (int i = 0; i < values.length; i++) {
      url.append(url.length() == 0 ? '?' : '&');

      if (namespace != null) {
        url.append(_reservedNamespace);
        url.append(namespace);
        url.append('.');
      }

      HttpUtil.encode(key, url);
      url.append('=');
      HttpUtil.encode(values[i], url);
    }
  }


  /**
   * @return a Set of all WindowState's used.
   */
  public Set<WindowState> getWindowStatesUsed()
  {
    if (_windowStatesUsed == null) {
      _windowStatesUsed = new HashSet<WindowState>();

      if (_invocationMap != null) {
        Iterator<Map.Entry<String, MapBasedInvocation>> iter
          = _invocationMap.entrySet().iterator();

        while (iter.hasNext()) {
          Map.Entry<String, MapBasedInvocation> entry = iter.next();
          _windowStatesUsed.add(entry.getValue().getWindowState());
        }
      }
    }

    if (_windowStatesUsed.isEmpty())
      _windowStatesUsed.add(WindowState.NORMAL);

    return _windowStatesUsed;
  }

  private void addWindowStateUsed(WindowState windowState)
  {
    if (_windowStatesUsed != null)
      _windowStatesUsed.add(windowState);
  }

  /**
   * @return a Set of all PortletMode's used.
   */
  public Set<PortletMode> getPortletModesUsed()
  {
    if (_portletModesUsed == null) {
      _portletModesUsed = new HashSet<PortletMode>();

      if (_invocationMap != null) {
        Iterator<Map.Entry<String, MapBasedInvocation>> iter
          = _invocationMap.entrySet().iterator();

        while (iter.hasNext()) {
          Map.Entry<String, MapBasedInvocation> entry = iter.next();
          _portletModesUsed.add(entry.getValue().getPortletMode());
        }
      }
    }

    if (_portletModesUsed.isEmpty())
      _portletModesUsed.add(PortletMode.VIEW);

    return _portletModesUsed;
  }

  private void addPortletModeUsed(PortletMode portletMode)
  {
    if (_portletModesUsed != null)
      _portletModesUsed.add(portletMode);
  }

  /**
   * Return a Invocation appropriate for the passed namespace.
   */
  public MapBasedInvocation getInvocation(String namespace)
  {
    if (namespace == null)
      throw new NullPointerException("namespace cannot be null");

    MapBasedInvocation invocation =  _invocationMap.get(namespace);

    if (invocation == null) {
      invocation = new MapBasedInvocation(this);

      invocation.start(namespace);
      _invocationMap.put(namespace, invocation);
    }

    return invocation;
  }

  protected InvocationURL createActionURL(String namespace)
  {
    MapBasedInvocationFactory clone = clone(namespace);
    clone._actionNamespace = namespace;
    return new MapBasedInvocationURL(clone, namespace);
  }

  protected InvocationURL createRenderURL(String namespace)
  {
    MapBasedInvocationFactory clone = clone(namespace);
    clone._actionNamespace = null;
    return new MapBasedInvocationURL(clone, namespace);
  }

  public String toString()
  {
    return "[MapBasedInvocationFactory actionNamespace=" + _actionNamespace
      + " invocationMap=" + _invocationMap
      + "]";
  }

  private static class MapBasedInvocation implements Invocation, Cloneable
  {
    private MapBasedInvocationFactory _factory;

    private String _namespace;
    private WindowState _windowState = WindowState.NORMAL;
    private PortletMode _portletMode = PortletMode.VIEW;
    private Map<String, String[]> _parameterMap; 

    public MapBasedInvocation(MapBasedInvocationFactory factory)
    {
      _factory = factory;
    }

    public void start(String namespace)
    {
      if (_namespace != null)
        throw new IllegalStateException("missing finish()?");

      _namespace = namespace;
    }

    public void finish()
    {
      _windowState = WindowState.NORMAL;
      _portletMode = PortletMode.VIEW;
      if (_parameterMap != null)
        _parameterMap.clear();
      _namespace = null;
    }

    public MapBasedInvocation clone(boolean keepParameters)
    {
      try {
        MapBasedInvocation clone = (MapBasedInvocation) super.clone();

        if (keepParameters && _parameterMap != null)
          clone._parameterMap 
            = new LinkedHashMap<String, String[]>(_parameterMap);
        else
          clone._parameterMap = null;

        return clone;
      }
      catch (CloneNotSupportedException ex) {
        throw new RuntimeException(ex);
      }
    }

    public String getNamespace()
    {
      return _namespace;
    }

    public boolean isActionTarget()
    {
      return _factory.isActionTarget(_namespace);
    }

    public Map<String, String[]> getParameterMap()
    {
      if (_parameterMap == null)
        _parameterMap = new LinkedHashMap<String, String[]>();

      return _parameterMap;
    }

    public Map<String, String[]> releaseParameterMap()
    {
      Map<String, String[]> map = getParameterMap();
      _parameterMap = null;
      return map;
    }

    public WindowState getWindowState()
    {
      return _windowState;
    }

    public void setWindowState(WindowState windowState)
    {
      _windowState = windowState == null ? WindowState.NORMAL : windowState;
      _factory.addWindowStateUsed(_windowState);
    }

    void setWindowStateName(String[] values)
    {
      String windowStateName 
        = values == null || values.length == 0 ? null : values[0];

      if (windowStateName == null)
        setWindowState(WindowState.NORMAL);
      else if (windowStateName.equals("normal"))
          setWindowState(WindowState.NORMAL);
      else if (windowStateName.equals("minimized"))
          setWindowState(WindowState.MINIMIZED);
      else if (windowStateName.equals("maximized"))
        setWindowState(WindowState.MAXIMIZED);
      else
        setWindowState(new WindowState(windowStateName));
    }

    public PortletMode getPortletMode()
    {
      return _portletMode;
    }

    public void setPortletMode(PortletMode portletMode)
    {
      _portletMode = portletMode == null ? PortletMode.VIEW : portletMode;
      _factory.addPortletModeUsed(_portletMode);
    }

    void setPortletModeName(String[] values)
    {
      String portletModeName 
        = values == null || values.length == 0 ? null : values[0];

      if (portletModeName == null)
        setPortletMode(PortletMode.VIEW);
      else if (portletModeName.equals("view"))
          setPortletMode(PortletMode.VIEW);
      else if (portletModeName.equals("edit"))
          setPortletMode(PortletMode.EDIT);
      else if (portletModeName.equals("help"))
          setPortletMode(PortletMode.HELP);
      else
        setPortletMode(new PortletMode(portletModeName));
    }

    public InvocationURL createActionURL()
    {
      return _factory.createActionURL(_namespace);
    }

    public InvocationURL createRenderURL()
    {
      return _factory.createRenderURL(_namespace);
    }

    public String toString()
    {
      return "[MapBasedInvocationFactory " 
        + " namespace=" + _namespace
        + " windowState=" + _windowState
        + " portletMode=" + _portletMode
        + " parameters=" + _parameterMap
        + "]";

    }
  }

  static class MapBasedInvocationURL 
    extends InvocationURL
  {
    MapBasedInvocationFactory _factory;

    MapBasedInvocationURL(MapBasedInvocationFactory factory, String namespace)
    {
      super(factory, namespace);
      _factory = factory;
    }

    public String getURL()
    {
      return _factory.getURL();
    }

  }
}