This method attaches one catalogue to the current one

        :parameter catalogue:
            An instance of :class:`htmk.seismicity.catalogue.Catalogue`
321103
def concatenate(self, catalogue):
        

        atts = getattr(self, 'data')
        attn = getattr(catalogue, 'data')
        data = _merge_data(atts, attn)

        if data is not None:
            setattr(self, 'data', data)
            for attrib in vars(self):
                atts = getattr(self, attrib)
                attn = getattr(catalogue, attrib)
                if attrib is 'end_year':
                    setattr(self, attrib, max(atts, attn))
                elif attrib is 'start_year':
                    setattr(self, attrib, min(atts, attn))
                elif attrib is 'data':
                    pass
                elif attrib is 'number_earthquakes':
                    setattr(self, attrib, atts + attn)
                elif attrib is 'processes':
                    if atts != attn:
                        raise ValueError('The catalogues cannot be merged' +
                                         ' since the they have' +
                                         ' a different processing history')
                else:
                    raise ValueError('unknown attribute: %s' % attrib)
        self.sort_catalogue_chronologically()
690440
def add_catalog_from_URL(self, votable_URL, votable_options={}):
        
        self.votable_URL= votable_URL
        self.votable_options= votable_options
        self.votable_from_URL_flag= not self.votable_from_URL_flag
1074328
def update(args):
    
    with _catalog(args) as cat:
        cat.update_metadata(
            args.args[0], dict([arg.split('=', 1) for arg in args.args[1:]]))
647106
public void attach(Pipe pipe)
    {
        //  If we are in the middle of sending a message, we'll add new pipe
        //  into the list of eligible pipes. Otherwise we add it to the list
        //  of active pipes.
        if (more) {
            pipes.add(pipe);
            Collections.swap(pipes, eligible, pipes.size() - 1);
            eligible++;
        }
        else {
            pipes.add(pipe);
            Collections.swap(pipes, active, pipes.size() - 1);
            active++;
            eligible++;
        }
    }
287889
def _init_catalog(self, proxy=None, runtime=None):
        """"""
        self._init_proxy_and_runtime(proxy, runtime)
        osid_name = self._session_namespace.split('.')[0]
        try:
            config = self._runtime.get_configuration()
            parameter_id = Id('parameter:' + osid_name + 'CatalogingProviderImpl@mongo')
            provider_impl = config.get_value_by_parameter(parameter_id).get_string_value()
            self._cataloging_manager = self._runtime.get_manager('CATALOGING', provider_impl)  # need to add version argument
        except (AttributeError, KeyError, errors.NotFound):
            pass
747406
public OrganizationModel attachOrganization(OrganizationModel organizationModel, ArchiveModel archiveModel)
    {
        for (OrganizationModel existingOrganizationModel : archiveModel.getOrganizationModels())
        {
            if (existingOrganizationModel.equals(organizationModel))
                return organizationModel;
        }
        organizationModel.addArchiveModel(archiveModel);
        return organizationModel;
    }
192810
def attachment(self, attachment):
        
        if isinstance(attachment, list):
            for a in attachment:
                self.add_attachment(a)
        else:
            self.add_attachment(attachment)
233198
def addItem(self, child, href):
        """"""
        assert isinstance(child, Base), "child must be a hypercat Catalogue or Resource"
        child.setHref(href)
        for item in self.items:
            assert item.href != href, "All items in a catalogue must have unique hrefs : "+href
        self.items += [child]           # Add new
        return
1213233
def rebuild_catalog_and_objects
      catalog = rebuild_catalog
      catalog[:Pages][:referenced_object][:Kids].each { |e| @objects << e[:referenced_object]; e[:referenced_object] }
      # adds every referenced object to the @objects (root), addition is performed as pointers rather then copies
      add_referenced()
      catalog
    end
831578
def add_code_mapping(self, from_pdb_code, to_pdb_code):
        ''''''

        # Consistency check - make sure that we always map the same code e.g. 'LIG' to the same code e.g. 'GTP'
        if from_pdb_code in self.code_map:
            assert(self.code_map[from_pdb_code] == to_pdb_code)
        else:
            self.code_map[from_pdb_code] = to_pdb_code
855843
def get_catalogue(args):
    """"""
    catalogue = tacl.Catalogue()
    catalogue.load(args.catalogue)
    return catalogue
384894
def add_from_catalog(catalog, test_module)
      coverable_resources = catalog.to_a.reject { |resource| !test_module.nil? && filter_resource?(resource, test_module) }
      coverable_resources.each do |resource|
        add(resource)
      end
    end
187817
public ClassificationModel attachLink(ClassificationModel classificationModel, LinkModel linkModel)
    {
        for (LinkModel existing : classificationModel.getLinks())
        {
            if (StringUtils.equals(existing.getLink(), linkModel.getLink()))
            {
                return classificationModel;
            }
        }
        classificationModel.addLink(linkModel);
        return classificationModel;
    }
1303267
def _set_catalog_view(self, session):
        """"""
        if self._catalog_view == COMPARATIVE:
            try:
                session.use_comparative_catalog_view()
            except AttributeError:
                pass
        else:
            try:
                session.use_plenary_catalog_view()
            except AttributeError:
                pass
1150813
protected void setCatalogs(List<File> pCatalogFiles, List<URL> pCatalogUrls ) throws MojoExecutionException
    {
        if ( catalogs == null || catalogs.length == 0 )
        {
            return;
        }

        for ( int i = 0; i < catalogs.length; i++ )
        {
            try
            {
                URL url = new URL( catalogs[i] );
                pCatalogUrls.add( url );
            }
            catch ( MalformedURLException e )
            {
                File absoluteCatalog = asAbsoluteFile( new File( catalogs[i] ) );
                if (!absoluteCatalog.exists() || !absoluteCatalog.isFile()){
                    throw new MojoExecutionException("That catalog does not exist:"+absoluteCatalog.getPath(), e);
                }
                pCatalogFiles.add(absoluteCatalog  );
            }
        }
    }
558134
protected function attachRelatedPiecesAfterSave()
    {
        if (isset($this->related_data['tvs'])) {
            $tvs = $this->related_data['tvs'];
            if (is_array($tvs) && count($tvs) > 0) {
                foreach ($tvs as $tv_name => $tv_data) {
                    $value = $this->convertToLocalTVData($tv_data);

                    $this->xPDOSimpleObject->setTVValue($tv_name, $value);
                }
            }
        }

        $this->assignResourceGroups();

        // extras
        $tagger = $this->blender->getTagger();
        if ($tagger instanceof \Tagger) {
            $this->setResourceTags($this->xPDOSimpleObject, (isset($this->related_data['extras']['tagger']) ? $this->related_data['extras']['tagger'] : []));
        }
    }
934315
def update_catalogs_if_needed(catalogs, templates)
      needs_update = templates.any? {|template| template.type == TemplateDeclarationType::CATALOG_TEMPLATE}

      return unless needs_update

      terminator = CatalogTerminator.new
      terminator.remove_all_catalogs
      puts('Updating shared generamba-catalog specs...')
      @catalog_downloader.download_catalog(GENERAMBA_CATALOG_NAME, RAMBLER_CATALOG_REPO)

      return unless catalogs != nil && catalogs.count > 0

      catalogs.each do |catalog_url|
        catalog_name = catalog_url.split('://').last
        catalog_name = catalog_name.gsub('/', '-');
        puts("Updating #{catalog_name} specs...")
        @catalog_downloader.download_catalog(catalog_name, catalog_url)
      end
    end