public LookupCommand() 
{
        this(CatalogFactory.getInstance());
}

Create an instance, setting its catalogFactory property to the value of CatalogFactory.getInstance().

since: Chain - 1.1

 public LookupCommand(CatalogFactory factory) 
{
        this.catalogFactory = factory;
}

Create an instance and initialize the catalogFactory property to given factory/

Parameters:

factory - The Catalog Factory.

since: Chain - 1.1

 public boolean execute(Context context) throws Exception 
{
        Command command = getCommand(context);
        if (command != null) {
            boolean result = (command.execute(context));
            if (isIgnoreExecuteResult()) {
                return false;
            }
            return result;
        } else {
            return (false);
        }
}

Look up the specified command, and (if found) execute it. Unless ignoreExecuteResult is set to true, return the result of executing the found command. If no command is found, return false, unless the optional property is false, in which case an IllegalArgumentException will be thrown.

 protected Catalog getCatalog(Context context) 
{
        CatalogFactory lookupFactory = this.catalogFactory;
        if (lookupFactory == null) {
            lookupFactory = CatalogFactory.getInstance();
        }
        String catalogName = getCatalogName();
        Catalog catalog = null;
        if (catalogName == null) {
            // use default catalog
            catalog = lookupFactory.getCatalog();
        } else {
            catalog = lookupFactory.getCatalog(catalogName);
        }
        if (catalog == null) {
            if (catalogName == null) {
                throw new IllegalArgumentException
                    ("Cannot find default catalog");
            } else {
                throw new IllegalArgumentException
                    ("Cannot find catalog '" + catalogName + "'");
            }
        }
        return catalog;
}

Return the Catalog to look up the Command in.

 public CatalogFactory getCatalogFactory() 
{
        return this.catalogFactory;
}

Return the CatalogFactory from which lookups will be performed.

 public String getCatalogName() 
{
                               
        return (this.catalogName);
}

Return the name of the Catalog to be searched, or null to search the default Catalog .

 protected Command getCommand(Context context) 
{
        Catalog catalog = getCatalog(context);
        Command command = null;
        String name = getCommandName(context);
        if (name != null) {
            command = catalog.getCommand(name);
            if ((command == null) && !isOptional()) {
                if (catalogName == null) {
                    throw new IllegalArgumentException
                        ("Cannot find command '" + name
                         + "' in default catalog");
                } else {
                    throw new IllegalArgumentException
                        ("Cannot find command '" + name
                         + "' in catalog '" + catalogName + "'");
                }
            }
            return (command);
        } else {
            throw new IllegalArgumentException("No command name");
        }
}

Return the Command instance to be delegated to.

 protected String getCommandName(Context context) 
{
        String name = getName();
        if (name == null) {
            name = (String) context.get(getNameKey());
        }
        return name;
}

Return the name of the Command instance to be delegated to.

 public String getName() 
{
                               
        return (this.name);
}

Return the name of the Command that we will look up and delegate execution to.

 public String getNameKey() 
{
                             
        return (this.nameKey);
}

Return the context attribute key under which the Command name is stored.

 public boolean isIgnoreExecuteResult() 
{
                                                            
        return ignoreExecuteResult;
}

Return true if this command should ignore the return value from executing the looked-up command. Defaults to false, which means that the return result of executing this lookup will be whatever is returned from that command.

 public boolean isIgnorePostprocessResult() 
{
                                                                    
        return ignorePostprocessResult;
}

Return true if this command is a Filter and should ignore the return value from executing the looked-up Filter's postprocess() method. Defaults to false, which means that the return result of executing this lookup will be whatever is returned from that Filter.

 public boolean isOptional() 
{
                         
        return (this.optional);
}

Return true if locating the specified command is optional.

 public boolean postprocess(Context context,
    Exception exception) 
{
        Command command = getCommand(context);
        if (command != null) {
            if (command instanceof Filter) {
                boolean result = (((Filter) command).postprocess(context, exception));
                if (isIgnorePostprocessResult()) {
                    return false;
                }
                return result;
            }
        }
        return (false);
}

If the executed command was itself a Filter , call the postprocess() method of that Filter as well.

 public  void setCatalogFactory(CatalogFactory catalogFactory) 
{
                           
        this.catalogFactory = catalogFactory;
}

Set the CatalogFactory from which lookups will be performed.

 public  void setCatalogName(String catalogName) 
{
        this.catalogName = catalogName;
}

Set the name of the Catalog to be searched, or null to search the default Catalog .

 public  void setIgnoreExecuteResult(boolean ignoreReturn) 
{
        this.ignoreExecuteResult = ignoreReturn;
}

Set the rules for whether or not this class will ignore or pass through the value returned from executing the looked up command.

If you are looking up a chain which may be "aborted" and you do not want this class to stop chain processing, then this value should be set to true

 public  void setIgnorePostprocessResult(boolean ignorePostprocessResult) 
{
        this.ignorePostprocessResult = ignorePostprocessResult;
}

Set the rules for whether or not this class will ignore or pass through the value returned from executing the looked up Filter's postprocess() method.

If you are looking up a Filter which may be "aborted" and you do not want this class to stop chain processing, then this value should be set to true

 public  void setName(String name) 
{
        this.name = name;
}

Set the name of the Command that we will look up and delegate execution to.

 public  void setNameKey(String nameKey) 
{
        this.nameKey = nameKey;
}

Set the context attribute key under which the Command name is stored.

 public  void setOptional(boolean optional) 
{
        this.optional = optional;
}

Set the optional flag for finding the specified command.