Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * (C) Copyright 2013 DataGenerator Contributors.
   *
   * Licensed 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 org.finra.datagenerator.generation;
 
 import java.util.List;
 import java.util.Set;
 
 public class AllCombosDataSetGenerator implements ICombiDataSetGenerator {
 
     private static final Logger log = Logger.getLogger(AllCombosDataSetGenerator.class);
 
     private static final AllCombosDataSetGenerator instance = new AllCombosDataSetGenerator();
     private static final ConcurrentMap<DataSpecList<DataSet>> dataSetCache = new MapMaker().makeMap();
 
     private AllCombosDataSetGenerator() {
     }
 
     public static AllCombosDataSetGenerator getInstance() {
         return ;
     }
 
     @Override
     public List<DataSetgenerateDataSets(DataSpec dataSpec) {
         // only recompute the datasets if they aren't in the cache
         synchronized () {
             if (!.containsKey(dataSpec)) {
                 .put(dataSpecinternalDataSetGeneration(dataSpec));
             }
         }
         // return defensive copy of the cached dataset
         List<DataSetret = new LinkedList<>();
         for(DataSet cachedDs : .get(dataSpec)){
             ret.add(new DataSet(cachedDs));
         }
         return ret;
     }

    
Generates datasets the cover every combination of positive values

Parameters:
dataSpec
Returns:
 
     private List<DataSetinternalDataSetGeneration(DataSpec dataSpec) {
 
         // The idea here is to take all of the variable specs, enumerate the positive values for each,
         // take the cartesian product of these sets, and then build a dataset for each set in the result
         ArrayList<VariableSpecvariableSpecs = Lists.newArrayList(dataSpec.getAllVariableSpecs());
 
         List<Set<String>> options = Lists.transform(variableSpecsnew Function<VariableSpecSet<String>>() {
             @Override
             public Set<Stringapply(VariableSpec varSpec) {
                 ..println(varSpec.getPropertySpec(.).getPositiveValues());
                 return Sets.newHashSet(varSpec.getPropertySpec(.).getPositiveValues());
             }
         });
 
         Set<List<String>> combos = Sets.cartesianProduct(options); // guava is awesome!!
 
         List<DataSetgeneratedDataSets = new LinkedList<>();
         for(List<Stringcombo : combos){
             DataSet comboDataSet = new DataSet();
             // each element in this combo corresponds directly to an elemnt in variableSpecs
             // so we advance two iterators through both lists, creating a variable and setting it's value
             Iterator<StringcomboIter = combo.iterator();
             Iterator<VariableSpecvarSpecIter = variableSpecs.iterator();
             for(int i = 0; i<combo.size(); ++i){
                 comboDataSet.createVariable(varSpecIter.next()).setProperty(.comboIter.next());
             }
             generatedDataSets.add(comboDataSet);
         }
         return generatedDataSets;
     }
New to GrepCode? Check out our FAQ X