    001    /*
    002     * Copyright (c) 2007-2014 Concurrent, Inc. All Rights Reserved.
    003     *
    004     * Project and contact information: http://www.cascading.org/
    005     *
    006     * This file is part of the Cascading project.
    007     *
    008     * Licensed under the Apache License, Version 2.0 (the "License");
    009     * you may not use this file except in compliance with the License.
    010     * You may obtain a copy of the License at
    011     *
    012     *     http://www.apache.org/licenses/LICENSE-2.0
    013     *
    014     * Unless required by applicable law or agreed to in writing, software
    015     * distributed under the License is distributed on an "AS IS" BASIS,
    016     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    017     * See the License for the specific language governing permissions and
    018     * limitations under the License.
    019     */
    020
    021    package cascading.cascade;
    022
    023    import java.util.Collection;
    024    import java.util.HashMap;
    025    import java.util.Map;
    026
    027    import cascading.flow.Flow;
    028    import cascading.property.UnitOfWorkDef;
    029
    030    /**
    031     * Class CascadeDef is a fluent interface for defining a {@link Cascade}.
    032     * <p/>
    033     * This allows for ad-hoc building of Cascade data and meta-data like tags.
    034     * <p/>
    035     * Instead of calling one of the {@link CascadeConnector} connect methods, {@link CascadeConnector#connect(CascadeDef)}
    036     * can be called.
    037     *
    038     * @see cascading.property.UnitOfWorkDef
    039     * @see cascading.flow.FlowDef
    040     */
    041    public class CascadeDef extends UnitOfWorkDef<CascadeDef>
    042      {
    043      Map<String, Flow> flows = new HashMap<String, Flow>();
    044      int maxConcurrentFlows = -1;
    045
    046      /**
    047       * Creates a new instance of a CascadeDef.
    048       *
    049       * @return a CascadeDef
    050       */
    051      public static CascadeDef cascadeDef()
    052        {
    053        return new CascadeDef();
    054        }
    055
    056      /** Constructor CascadeDef creates a new CascadeDef instance. */
    057      public CascadeDef()
    058        {
    059        }
    060
    061      /**
    062       * Method getFlows returns the flows of this CascadeDef object.
    063       *
    064       * @return the flows (type Collection<Flow>) of this CascadeDef object.
    065       */
    066      public Collection<Flow> getFlows()
    067        {
    068        return flows.values();
    069        }
    070
    071      /**
    072       * Method getFlowsArray returns the flows as an array of this CascadeDef object.
    073       *
    074       * @return the flowsArray (type Flow[]) of this CascadeDef object.
    075       */
    076      public Flow[] getFlowsArray()
    077        {
    078        return getFlows().toArray( new Flow[ flows.size() ] );
    079        }
    080
    081      /**
    082       * Method addFlow adds a new {@link cascading.flow.Flow} instance that is intended to participate in a {@link Cascade}.
    083       *
    084       * @param flow of Flow
    085       * @return CascadeDef
    086       */
    087      public CascadeDef addFlow( Flow flow )
    088        {
    089        if( flow == null )
    090          return this;
    091
    092        if( flows.containsKey( flow.getName() ) )
    093          throw new CascadeException( "all flow names must be unique, found duplicate: " + flow.getName() );
    094
    095        flows.put( flow.getName(), flow );
    096
    097        return this;
    098        }
    099
    100      /**
    101       * Method addFlows adds many new {@link cascading.flow.Flow} instances intended to participate in a {@link Cascade}.
    102       *
    103       * @param flows of Flow[]
    104       * @return CascadeDef
    105       */
    106      public CascadeDef addFlows( Flow... flows )
    107        {
    108        for( Flow flow : flows )
    109          addFlow( flow );
    110
    111        return this;
    112        }
    113
    114      /**
    115       * Method addFlows adds many new {@link cascading.flow.Flow} instances intended to participate in a {@link Cascade}.
    116       *
    117       * @param flows of Collection<Flow>
    118       * @return CascadeDef
    119       */
    120      public CascadeDef addFlows( Collection<Flow> flows )
    121        {
    122        for( Flow flow : flows )
    123          addFlow( flow );
    124
    125        return this;
    126        }
    127
    128      public CascadeDef setMaxConcurrentFlows( int maxConcurrentFlows )
    129        {
    130        this.maxConcurrentFlows = maxConcurrentFlows;
    131
    132        return this;
    133        }
    134
    135      public int getMaxConcurrentFlows()
    136        {
    137        return maxConcurrentFlows;
    138        }
    139      }