ServiceCatalog class

@description wrapper for the service catalog response from keystone

@param {object}  catalog     the raw data to parse into the catalog
@constructor
344584
function (catalog) {
  var self = this;

  self.services = {};

  _.each(catalog, function (service) {
    // Special hack for rackspace with two compute types
    if (service.type === 'compute' && service.name === 'cloudServers') {
      return;
    }

    self.services[service.name] = new Service(service);
  });
}
1097204
def catalog
      @catalog_mutex.synchronize do
        break if synchronized?
        logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
        api_map.catalog bundle
        @synchronized = true
        logger.info "Catalog complete (#{api_map.pins.length} pins)"
      end
    end
691870
function() {
            var self = this;
            return waterline.catalogs.findOne({"node": self.id})
            .then(function(catalog) {
                return !_.isEmpty(catalog);
            });
        }
79208
function (category) {
    return this.get('/getappsincategory', {
      // 'cc': this.options.country,
      // 'l': this.options.language,
      'category': category
    }).then(function (body) {
      console.log('getAppsInCategory - ', body)
      return Promise.resolve(body);
    });
  }
612591
function getDataBasedOnCatalog(options, catalogs, models, cb) {

  async.each(catalogs,
    function(catalog, catcallback) {
      /* Next, go to APIs for each catalog */
      async.each(models,
        function(model, modelcallback) {
          pullDataFromEndp(options, catalog, model, function(err) {
            if (err) {
              logger.error(err);
            }
            modelcallback(err);
          });
        },
        function(err) {
          catcallback(err);
        });
    },
    function(err) {
      cb(err, response);
    }
  );
}
1272373
def catalog_components(self, catalog_name, split_ver):
        
        return sorted(self._split_comp_info_dicts["%s_%s" % (catalog_name, split_ver)].keys())
1305992
def catalogFactory(name, **kwargs):
    
    fn = lambda member: inspect.isclass(member) and member.__module__==__name__
    catalogs = odict(inspect.getmembers(sys.modules[__name__], fn))

    if name not in list(catalogs.keys()):
        msg = "%s not found in catalogs:\n %s"%(name,list(kernels.keys()))
        logger.error(msg)
        msg = "Unrecognized catalog: %s"%name
        raise Exception(msg)

    return catalogs[name](**kwargs)
385306
public final void setCatalog(String catalog) throws SQLException 
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "Set Catalog to " + catalog); 
        sqlConn.setCatalog(catalog);
        connectionPropertyChanged = true; 
    }
1217704
def build_catalog(self, body):
        
        for child in body.children:
            if self.soaproot(child):
                self.nodes.append(child)
            id = child.get('id')
            if id is None:
                continue
            key = '#%s' % id
            self.catalog[key] = child
1307379
def get_catalog_info(self, key=None, default=None):
        
        if key is None:
            return self._init_kwargs

        return self._init_kwargs.get(key, default)
401819
def update_ar_listing_catalog(portal):
    
    cat_id = CATALOG_ANALYSIS_REQUEST_LISTING

    catalog = api.get_tool(cat_id)

    logger.info("Updating Indexes/Metadata of Catalog '{}'".format(cat_id))

    indexes_to_add = [
        # name, attribute, metatype
        ("getClientID", "getClientID", "FieldIndex"),
        ("is_active", "is_active", "BooleanIndex"),
        ("is_received", "is_received", "BooleanIndex"),
    ]

    metadata_to_add = [
        "getClientID",
    ]

    for index in indexes_to_add:
        add_index(portal, cat_id, *index)

    for metadata in metadata_to_add:
        refresh = metadata not in catalog.schema()
        add_metadata(portal, cat_id, metadata, refresh_catalog=refresh)
919148
function(terria) {
  CatalogMember.call(this, terria);

  this._loadingPromise = undefined;
  this._lastLoadInfluencingValues = undefined;
  this._parameters = [];

  /**
   * Gets or sets a value indicating whether the group is currently loading.  This property
   * is observable.
   * @type {Boolean}
   */
  this.isLoading = false;

  /**
   * A catalog item that will be enabled while preparing to invoke this catalog function, in order to
   * provide context for the function.
   * @type {CatalogItem}
   */
  this.contextItem = undefined;

  knockout.track(this, ["isLoading"]);
}
852249
public final void setItsCatalog(final CatalogGs pCatalog) {
    this.itsCatalog = pCatalog;
    if (this.itsId == null) {
      this.itsId = new SeGoodCatalogId();
    }
    this.itsId.setItsCatalog(this.itsCatalog);
  }
1236720
def make_query(catalog):
    
    query = {}
    request = api.get_request()
    index = get_search_index_for(catalog)
    limit = request.form.get("limit")

    q = request.form.get("q")
    if len(q) > 0:
        query[index] = q + "*"
    else:
        return None

    portal_type = request.form.get("portal_type")
    if portal_type:
        if not isinstance(portal_type, list):
            portal_type = [portal_type]
        query["portal_type"] = portal_type

    if limit and limit.isdigit():
        query["sort_limit"] = int(limit)

    return query
1068107
private synchronized void create(CatalogContext catalogContext) {
        try {
            Map<String, ImportConfiguration> newProcessorConfig = loadNewConfigAndBundles(catalogContext);
            restartImporters(newProcessorConfig);
        } catch (final Exception e) {
            VoltDB.crashLocalVoltDB("Error creating import processor", true, e);
        }
    }
525626
function Service(config) {
    if (!this.loadServiceClass) {
      throw AWS.util.error(new Error(),
        'Service must be constructed with `new\' operator');
    }
    var ServiceClass = this.loadServiceClass(config || {});
    if (ServiceClass) {
      var originalConfig = AWS.util.copy(config);
      var svc = new ServiceClass(config);
      Object.defineProperty(svc, '_originalConfig', {
        get: function() { return originalConfig; },
        enumerable: false,
        configurable: true
      });
      svc._clientId = ++clientCount;
      return svc;
    }
    this.initialize(config);
  }
264250
function(service)
    {
        var moduleName = this.moduleName = 'I' + service.serviceName;
        this.append('module.exports = ' + moduleName +
            ' = require(\'typedef\')');
        this.addBreak(2);
        this.addDisclaimer();
        this.addBreak();
        this.addComment(service.description);
        this.append('.interface(\'' + moduleName + '\') .define({');
        this.addBreak();

	    var processedMethods = [];
        service.methods.forEach(function(method, index) {
	        if (processedMethods.indexOf(method.name) >= 0) {
		        return;
	        }
	        processedMethods.push(method.name);
            if (index) this.code += ',\n';
            this.addMethod(method);
        }.bind(this));

        this.addBreak(2);
        this.append('});');
    }